itamae-mitsurin 0.50 → 1.0.0

data/test/test_itamae-mitsurin/test_backend.rb

@@ -1,297 +0,0 @@
-require 'specinfra/core'
-require 'singleton'
-require 'io/console'
-require 'net/ssh'
-
-Specinfra::Configuration.error_on_missing_backend_type = true
-
-module Specinfra
-  module Configuration
-    def self.sudo_password
-      return ENV['SUDO_PASSWORD'] if ENV['SUDO_PASSWORD']
-      return @sudo_password if @sudo_password
-
-      # TODO: Fix this dirty hack
-      return nil unless caller.any? {|call| call.include?('channel_data') }
-
-      print "sudo password: "
-      @sudo_password = STDIN.noecho(&:gets).strip
-      print "\n"
-      @sudo_password
-    end
-  end
-end
-
-module TestItamaeMitsurin
-  module TestBackend
-    UnknownBackendTypeError = Class.new(StandardError)
-    CommandExecutionError = Class.new(StandardError)
-    SourceNotExistError = Class.new(StandardError)
-
-    class << self
-      def create(type, opts = {})
-        self.const_get(type.capitalize).new(opts)
-      end
-    end
-
-    class Base < Test::Unit::TestCase
-      attr_reader :executed_commands
-
-      def initialize(options)
-        @options = options
-        @backend = create_specinfra_backend
-        @executed_commands = []
-      end
-
-      def run_command(commands, options = {})
-        options = {error: true}.merge(options)
-
-        command = build_command(commands, options)
-        TestItamaeMitsurin.logger.debug "Executing `#{command}`..."
-
-        result = nil
-
-        TestItamaeMitsurin.logger.with_indent do
-          reset_output_handler
-
-          result = run_command_with_profiling(command)
-
-          flush_output_handler_buffer
-
-          if result.exit_status == 0 || !options[:error]
-            method = :debug
-            message = "exited with #{result.exit_status}"
-          else
-            method = :error
-            message = "Command `#{command}` failed. (exit status: #{result.exit_status})"
-
-            unless TestItamaeMitsurin.logger.level == ::Logger::DEBUG
-              result.stdout.each_line do |l|
-                log_output_line("stdout", l, :error)
-              end
-              result.stderr.each_line do |l|
-                log_output_line("stderr", l, :error)
-              end
-            end
-          end
-
-          TestItamaeMitsurin.logger.public_send(method, message)
-        end
-
-        if options[:error] && result.exit_status != 0
-          raise CommandExecutionError
-        end
-
-        result
-      end
-
-      def get_command(*args)
-        @backend.command.get(*args)
-      end
-
-      def receive_file(src, dst = nil)
-        if dst
-          TestItamaeMitsurin.logger.debug "Receiving a file from '#{src}' to '#{dst}'..."
-        else
-          TestItamaeMitsurin.logger.debug "Receiving a file from '#{src}'..."
-        end
-        @backend.receive_file(src, dst)
-      end
-
-      def send_file(src, dst)
-        TestItamaeMitsurin.logger.debug "Sending a file from '#{src}' to '#{dst}'..."
-        unless ::File.exist?(src)
-          raise SourceNotExistError, "The file '#{src}' doesn't exist."
-        end
-        unless ::File.file?(src)
-          raise SourceNotExistError, "'#{src}' is not a file."
-        end
-        @backend.send_file(src, dst)
-      end
-
-      def send_directory(src, dst)
-        TestItamaeMitsurin.logger.debug "Sending a directory from '#{src}' to '#{dst}'..."
-        unless ::File.exist?(src)
-          raise SourceNotExistError, "The directory '#{src}' doesn't exist."
-        end
-        unless ::File.directory?(src)
-          raise SourceNotExistError, "'#{src}' is not a directory."
-        end
-        @backend.send_directory(src, dst)
-      end
-
-      def host_inventory
-        @backend.host_inventory
-      end
-
-      def finalize
-        # pass
-      end
-
-      private
-
-      def create_specinfra_backend
-        raise NotImplementedError
-      end
-
-      def reset_output_handler
-        @buf = {}
-        %w!stdout stderr!.each do |output_name|
-          @buf[output_name] = ""
-          handler = lambda do |str|
-            lines = str.split(/\r?\n/, -1)
-            @buf[output_name] += lines.pop
-            unless lines.empty?
-              lines[0] = @buf[output_name] + lines[0]
-              @buf[output_name] = ""
-              lines.each do |l|
-                log_output_line(output_name, l)
-              end
-            end
-          end
-          @backend.public_send("#{output_name}_handler=", handler)
-        end
-      end
-
-      def flush_output_handler_buffer
-        @buf.each do |output_name, line|
-          next if line.empty?
-          log_output_line(output_name, line)
-        end
-      end
-
-      def log_output_line(output_name, line, severity = :debug)
-        line = line.gsub(/[[:cntrl:]]/, '')
-        TestItamaeMitsurin.logger.public_send(severity, "#{output_name} | #{line}")
-      end
-
-      def build_command(commands, options)
-        if commands.is_a?(Array)
-          command = commands.map do |cmd|
-            cmd.shellescape
-          end.join(' ')
-        else
-          command = commands
-        end
-
-        cwd = options[:cwd]
-        if cwd
-          command = "cd #{cwd.shellescape} && #{command}"
-        end
-
-        user = options[:user]
-        if user
-          command = "cd ~#{user.shellescape} ; #{command}"
-          command = "sudo -H -u #{user.shellescape} -- #{shell.shellescape} -c #{command.shellescape}"
-        end
-
-        command
-      end
-
-      def shell
-        @options[:shell] || '/bin/sh'
-      end
-
-      def run_command_with_profiling(command)
-        start_at = Time.now
-        result = @backend.run_command(command)
-        duration = Time.now.to_f - start_at.to_f
-
-        @executed_commands << {command: command, duration: duration}
-
-        result
-      end
-    end
-
-    class Local < Base
-      private
-      def create_specinfra_backend
-        Specinfra::Backend::Exec.new(
-          shell: @options[:shell],
-        )
-      end
-    end
-
-    class Ssh < Base
-      private
-      def create_specinfra_backend
-        Specinfra::Backend::Ssh.new(
-          request_pty: true,
-          host: ssh_options[:host_name],
-          disable_sudo: disable_sudo?,
-          ssh_options: ssh_options,
-          shell: @options[:shell],
-        )
-      end
-
-      def ssh_options
-        opts = {}
-
-        opts[:host_name] = @options[:host]
-
-        # from ssh-config
-        opts.merge!(Net::SSH::Config.for(@options[:host]))
-        opts[:user] = @options[:user] || opts[:user] || Etc.getlogin
-        opts[:keys] = [@options[:key]] if @options[:key]
-        opts[:port] = @options[:port] if @options[:port]
-
-        if @options[:vagrant]
-          config = Tempfile.new('', Dir.tmpdir)
-          hostname = opts[:host_name] || 'default'
-          vagrant_cmd = "vagrant ssh-config #{hostname} > #{config.path}"
-          if defined?(Bundler)
-            Bundler.with_clean_env do
-              `#{vagrant_cmd}`
-            end
-          else
-            `#{vagrant_cmd}`
-          end
-          opts.merge!(Net::SSH::Config.for(hostname, [config.path]))
-        end
-
-        if @options[:ask_password]
-          print "password: "
-          unless ENV['SSH_PASSWORD'].nil?
-            password = ENV['SSH_PASSWORD']
-          else
-            password = STDIN.noecho(&:gets).strip
-          end
-          print "\n"
-          opts.merge!(password: password)
-        end
-
-        opts
-      end
-
-      def disable_sudo?
-        !@options[:sudo]
-      end
-    end
-
-    class Docker < Base
-      def finalize
-        image = @backend.commit_container
-        TestItamaeMitsurin.logger.info "Image created: #{image.id}"
-      end
-
-      private
-      def create_specinfra_backend
-        begin
-          require 'docker'
-        rescue LoadError
-          TestItamaeMitsurin.logger.fatal "To use docker backend, please install 'docker-api' gem"
-        end
-
-        # TODO: Move to Specinfra?
-        Excon.defaults[:ssl_verify_peer] = @options[:tls_verify_peer]
-        ::Docker.logger = TestItamaeMitsurin.logger
-
-        Specinfra::Backend::Docker.new(
-          docker_image: @options[:image],
-          docker_container: @options[:container],
-          shell: @options[:shell],
-        )
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/test_cli.rb

@@ -1,88 +0,0 @@
-require 'itamae-mitsurin'
-require 'thor'
-require 'test/unit'
-include Test::Unit::TestCase
-
-module TestItamaeMitsurin
-  class TestCLI < Thor
-
-    class_option :log_level, type: :string, aliases: ['-l'], default: 'info'
-    class_option :color, type: :boolean, default: true
-    class_option :config, type: :string, aliases: ['-c']
-
-    def initialize(*)
-      super
-
-      ItamaeMitsurin.logger.level = ::Logger.const_get(options[:log_level].upcase)
-      ItamaeMitsurin.logger.formatter.colored = options[:color]
-    end
-
-    def self.define_exec_options
-      option :recipe_graph, type: :string, desc: "[EXPERIMENTAL] Write recipe dependency graph in DOT", banner: "PATH"
-      option :node_json, type: :string, aliases: ['-j']
-      option :node_yaml, type: :string, aliases: ['-y']
-      option :dry_run, type: :boolean, aliases: ['-n']
-      option :shell, type: :string, default: "/bin/sh"
-      option :ohai, type: :boolean, default: false, desc: "This option is DEPRECATED and will be unavailable."
-      option :profile, type: :string, desc: "[EXPERIMENTAL] Save profiling data", banner: "PATH"
-    end
-
-    desc "local RECIPE [RECIPE...]", "Run Itamae locally"
-    define_exec_options
-    def local(*recipe_files)
-      if recipe_files.empty?
-        raise "Please specify recipe files."
-      end
-
-      Runner.run(recipe_files, :local, options)
-    end
-
-    desc "ssh RECIPE [RECIPE...]", "Run Itamae via ssh"
-    define_exec_options
-    option :host, type: :string, aliases: ['-h']
-    option :user, type: :string, aliases: ['-u']
-    option :key, type: :string, aliases: ['-i']
-    option :port, type: :numeric, aliases: ['-p']
-    option :vagrant, type: :boolean, default: false
-    option :ask_password, type: :boolean, default: false
-    option :sudo, type: :boolean, default: true
-    def ssh(*recipe_files)
-      if recipe_files.empty?
-        raise "Please specify recipe files."
-      end
-
-      unless options[:host] || options[:vagrant]
-        raise "Please set '-h <hostname>' or '--vagrant'"
-      end
-
-      Runner.run(recipe_files, :ssh, options)
-    end
-
-    desc "docker RECIPE [RECIPE...]", "Create Docker image"
-    define_exec_options
-    option :image, type: :string, desc: "This option or 'container' option is required."
-    option :container, type: :string, desc: "This option or 'image' option is required."
-    option :tls_verify_peer, type: :boolean, default: true
-    def docker(*recipe_files)
-      if recipe_files.empty?
-        raise "Please specify recipe files."
-      end
-
-      Runner.run(recipe_files, :docker, options)
-    end
-
-    desc "version", "Print version"
-    def version
-      puts "itamae-mitsurin v#{ItamaeMitsurin::VERSION}"
-    end
-
-    private
-    def options
-      @itamae_options ||= super.dup.tap do |options|
-        if config = options[:config]
-          options.merge!(YAML.load_file(config))
-        end
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/test_definition.rb

@@ -1,40 +0,0 @@
-require 'itamae-mitsurin'
-
-module ItamaeMitsurin
-  class Definition < Resource::Base
-    class << self
-      attr_accessor :definition_block
-      attr_accessor :defined_in_recipe
-
-      def create_class(name, params, defined_in_recipe, &block)
-        Class.new(self).tap do |klass|
-          klass.definition_block = block
-          klass.defined_in_recipe = defined_in_recipe
-
-          klass.define_attribute :action, default: :run
-          params.each_pair do |key, value|
-            klass.define_attribute key.to_sym, type: Object, default: value
-          end
-        end
-      end
-    end
-
-    def initialize(*args)
-      super
-
-      r = Recipe::RecipeFromDefinition.new(
-        runner,
-        self.class.defined_in_recipe.path,
-      )
-      recipe.children << r
-
-      r.definition = self
-      r.load(params: @attributes.merge(name: resource_name))
-    end
-
-    def run(*args)
-      # nothing
-    end
-  end
-end
-

data/test/test_itamae-mitsurin/test_ext.rb

@@ -1 +0,0 @@
-require 'itamae-mitsurin/ext/specinfra'

data/test/test_itamae-mitsurin/test_handler.rb

@@ -1,21 +0,0 @@
-require 'itamae-mitsurin/handler/base'
-
-module ItamaeMitsurin
-  module Handler
-    def self.from_type(type)
-      first_time = true
-
-      class_name = type.split('_').map(&:capitalize).join
-      self.const_get(class_name)
-    rescue NameError
-      require "itamae-mitsurin/handler/#{type}"
-
-      if first_time
-        first_time = false
-        retry
-      else
-        raise
-      end
-    end
-  end
-end