itamae-mitsurin 0.4 → 0.7

data/test/test_itamae-mitsurin/resource/test_local_ruby_block.rb

@@ -0,0 +1,15 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class LocalRubyBlock < Base
+      define_attribute :action, default: :run
+      define_attribute :block, type: Proc
+
+      def action_run(options)
+        attributes.block.call
+      end
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/resource/test_package.rb

@@ -0,0 +1,44 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class Package < Base
+      define_attribute :action, default: :install
+      define_attribute :name, type: String, default_name: true
+      define_attribute :version, type: String
+      define_attribute :options, type: String
+
+      def pre_action
+        case @current_action
+        when :install
+          attributes.installed = true
+        when :remove
+          attributes.installed = false
+        end
+      end
+
+      def set_current_attributes
+        current.installed = run_specinfra(:check_package_is_installed, attributes.name)
+
+        if current.installed
+          current.version = run_specinfra(:get_package_version, attributes.name).stdout.strip
+        end
+      end
+
+      def action_install(action_options)
+        unless run_specinfra(:check_package_is_installed, attributes.name, attributes.version)
+          run_specinfra(:install_package, attributes.name, attributes.version, attributes.options)
+          updated!
+        end
+      end
+
+      def action_remove(action_options)
+        if run_specinfra(:check_package_is_installed, attributes.name, nil)
+          run_specinfra(:remove_package, attributes.name, attributes.options)
+          updated!
+        end
+      end
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/resource/test_remote_directory.rb

@@ -0,0 +1,84 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class RemoteDirectory < Base
+      define_attribute :action, default: :create
+      define_attribute :path, type: String, default_name: true
+      define_attribute :source, type: String, required: true
+      define_attribute :mode, type: String
+      define_attribute :owner, type: String
+      define_attribute :group, type: String
+
+      def pre_action
+        directory = ::File.expand_path(attributes.source, ::File.dirname(@recipe.path))
+        src = ::File.expand_path(directory, ::File.dirname(@recipe.path))
+
+        @temppath = ::File.join(runner.tmpdir, Time.now.to_f.to_s)
+        backend.send_directory(src, @temppath)
+
+        case @current_action
+        when :create
+          attributes.exist = true
+        end
+      end
+
+      def set_current_attributes
+        current.exist = run_specinfra(:check_file_is_directory, attributes.path)
+
+        if current.exist
+          current.mode  = run_specinfra(:get_file_mode, attributes.path).stdout.chomp
+          current.owner = run_specinfra(:get_file_owner_user, attributes.path).stdout.chomp
+          current.group = run_specinfra(:get_file_owner_group, attributes.path).stdout.chomp
+        else
+          current.mode  = nil
+          current.owner = nil
+          current.group = nil
+        end
+      end
+
+      def show_differences
+        super
+
+        if current.exist
+          diff = run_command(["diff", "-u", attributes.path, @temppath], error: false)
+          if diff.exit_status == 0
+            # no change
+            ItamaeMitsurin.logger.debug "directory content will not change"
+          else
+            ItamaeMitsurin.logger.info "diff:"
+            diff.stdout.each_line do |line|
+              ItamaeMitsurin.logger.info "#{line.strip}"
+            end
+          end
+        end
+      end
+
+      def action_create(options)
+        if attributes.mode
+          run_specinfra(:change_file_mode, @temppath, attributes.mode)
+        end
+        if attributes.owner || attributes.group
+          run_specinfra(:change_file_owner, @temppath, attributes.owner, attributes.group)
+        end
+
+        if run_specinfra(:check_file_is_file, attributes.path)
+          unless check_command(["diff", "-q", @temppath, attributes.path])
+            updated!
+          end
+        else
+          updated!
+        end
+
+        run_specinfra(:remove_file, attributes.path)
+        run_specinfra(:move_file, @temppath, attributes.path)
+      end
+
+      def action_delete(options)
+        if run_specinfra(:check_file_is_directory, attributes.path)
+          run_specinfra(:remove_file, attributes.path)
+        end
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/resource/test_remote_file.rb

@@ -0,0 +1,54 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class RemoteFile < File
+      SourceNotFoundError = Class.new(StandardError)
+
+      define_attribute :source, type: [String, Symbol], default: :auto
+
+      private
+
+      def content_file
+        source_file
+      end
+
+      def source_file
+        @source_file ||= find_source_file
+      end
+
+      def find_source_file
+        if attributes.source == :auto
+          dirs = attributes.path.split(::File::SEPARATOR)
+          dirs.shift if dirs.first == ""
+
+          searched_paths = []
+          dirs.size.times do |i|
+            source_file_exts.each do |ext|
+              path = ::File.join(@recipe.dir, source_file_dir, "#{dirs[i..-1].join("/")}#{ext}")
+              if ::File.exist?(path)
+                ItamaeMitsurin.logger.debug "#{path} is used as a source file."
+                return path
+              else
+                searched_paths << path
+              end
+            end
+          end
+
+          raise SourceNotFoundError, "source file is not found (searched paths: #{searched_paths.join(', ')})"
+        else
+          ::File.expand_path(attributes.source, @recipe.dir)
+        end
+      end
+
+      def source_file_dir
+        "files"
+      end
+
+      def source_file_exts
+        [""]
+      end
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/resource/test_service.rb

@@ -0,0 +1,69 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class Service < Base
+      define_attribute :action, default: :nothing
+      define_attribute :name, type: String, default_name: true
+      define_attribute :provider, type: Symbol, default: nil
+
+      def initialize(*args)
+        super
+        @under = attributes.provider ? "_under_#{attributes.provider}" : ""
+      end
+
+      def pre_action
+        case @current_action
+        when :start, :restart
+          attributes.running = true
+        when :stop
+          attributes.running = false
+        when :enable
+          attributes.enabled = true
+        when :disable
+          attributes.enabled = false
+        end
+      end
+
+      def set_current_attributes
+        current.running = run_specinfra(:"check_service_is_running#{@under}", attributes.name)
+        current.enabled = run_specinfra(:"check_service_is_enabled#{@under}", attributes.name)
+      end
+
+      def action_start(options)
+        unless current.running
+          run_specinfra(:"start_service#{@under}", attributes.name)
+        end
+      end
+
+      def action_stop(options)
+        if current.running
+          run_specinfra(:"stop_service#{@under}", attributes.name)
+        end
+      end
+
+      def action_restart(options)
+        run_specinfra(:"restart_service#{@under}", attributes.name)
+      end
+
+      def action_reload(options)
+        if current.running
+          run_specinfra(:"reload_service#{@under}", attributes.name)
+        end
+      end
+
+      def action_enable(options)
+        unless current.enabled
+          run_specinfra(:"enable_service#{@under}", attributes.name)
+        end
+      end
+
+      def action_disable(options)
+        if current.enabled
+          run_specinfra(:"disable_service#{@under}", attributes.name)
+        end
+      end
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/resource/test_template.rb

@@ -0,0 +1,53 @@
+require 'itamae-mitsurin'
+require 'erb'
+require 'tempfile'
+
+module ItamaeMitsurin
+  module Resource
+    class Template < RemoteFile
+      define_attribute :variables, type: Hash, default: {}
+
+      def pre_action
+        attributes.content = RenderContext.new(self).render_file(source_file)
+
+        super
+      end
+
+      private
+
+      def content_file
+        nil
+      end
+
+      def source_file_dir
+        "templates"
+      end
+
+      def source_file_exts
+        [".erb", ""]
+      end
+
+      class RenderContext
+        def initialize(resource)
+          @resource = resource
+
+          @resource.attributes.variables.each_pair do |key, value|
+            instance_variable_set("@#{key}".to_sym, value)
+          end
+        end
+
+        def render_file(src)
+          template = ::File.read(src)
+          ERB.new(template, nil, '-').tap do |erb|
+            erb.filename = src
+          end.result(binding)
+        end
+
+        def node
+          @resource.recipe.runner.node
+        end
+      end
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/resource/test_user.rb

@@ -0,0 +1,93 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  module Resource
+    class User < Base
+      define_attribute :action, default: :create
+      define_attribute :username, type: String, default_name: true
+      define_attribute :gid, type: [Integer, String]
+      define_attribute :home, type: String
+      define_attribute :password, type: String
+      define_attribute :system_user, type: [TrueClass, FalseClass]
+      define_attribute :uid, type: Integer
+      define_attribute :shell, type: String
+      define_attribute :create_home, type: [TrueClass, FalseClass], default: false
+
+      def pre_action
+        case @current_action
+        when :create
+          attributes.exist = true
+        end
+      end
+
+      def set_current_attributes
+        current.exist = exist?
+
+        if current.exist
+          current.uid = run_specinfra(:get_user_uid, attributes.username).stdout.strip.to_i
+          current.gid = run_specinfra(:get_user_gid, attributes.username).stdout.strip.to_i
+          current.home = run_specinfra(:get_user_home_directory, attributes.username).stdout.strip
+          current.shell = run_specinfra(:get_user_login_shell, attributes.username).stdout.strip
+          current.password = current_password
+        end
+      end
+
+      def action_create(options)
+        if run_specinfra(:check_user_exists, attributes.username)
+          if attributes.uid && attributes.uid != current.uid
+            run_specinfra(:update_user_uid, attributes.username, attributes.uid)
+            updated!
+          end
+
+          if attributes.gid && attributes.gid != current.gid
+            run_specinfra(:update_user_gid, attributes.username, attributes.gid)
+            updated!
+          end
+
+          if attributes.password && attributes.password != current.password
+            run_specinfra(:update_user_encrypted_password, attributes.username, attributes.password)
+            updated!
+          end
+
+          if attributes.home && attributes.home != current.home
+            run_specinfra(:update_user_home_directory, attributes.username, attributes.home)
+            updated!
+          end
+
+          if attributes.shell && attributes.shell != current.shell
+            run_specinfra(:update_user_login_shell, attributes.username, attributes.shell)
+            updated!
+          end
+        else
+          options = {
+            gid:            attributes.gid,
+            home_directory: attributes.home,
+            password:       attributes.password,
+            system_user:    attributes.system_user,
+            uid:            attributes.uid,
+            shell:          attributes.shell,
+            create_home:    attributes.create_home,
+          }
+
+          run_specinfra(:add_user, attributes.username, options)
+
+          updated!
+        end
+      end
+
+      private
+      def exist?
+        run_specinfra(:check_user_exists, attributes.username)
+      end
+
+      def current_password
+        result = run_specinfra(:get_user_encrypted_password, attributes.username)
+        if result.success?
+          result.stdout.strip
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_backend.rb

@@ -0,0 +1,297 @@
+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