specinfra 2.0.0.beta31 → 2.0.0.beta32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2a1bd40a04d44b67623cb28435448880491f37c
-  data.tar.gz: 83162af96a81794b41a31f66205d0c14ccf85394
+  metadata.gz: 6bdf29071ca5229cf86e2c3652d9e5aff5a95adf
+  data.tar.gz: 3316f09764ff4c1bdf3e77ca77d1e1b50473fbbe
 SHA512:
-  metadata.gz: ef8fe7cd152d0a92c7ac37af804c29fe6352ab7c475a0b529d7f6e243f891a0393773c416a46b86bb5dcb89c421aa3fa15c2247b7f26db33a7e57966b76e98fa
-  data.tar.gz: 1742365c04717af0b1775969959926bcf4556a9f140a4f07206ad76b63fd4cb39d8b0298a4936e95be8b353de5e4c503d660f8220b7b1928c2fd2211ba513347
+  metadata.gz: d47a9c0b81348438f99b5d9f8074c6442b0d7e35ce86e802b24c7a5350ef93c1994dba0b4d66d71b99c7fd52febdc580de8b9dddc2c0daa23421ec17b67de137
+  data.tar.gz: cf65c9ea30eb98dd69890127ecdfc1ce1649eaa02787db878a95ac6156ca61b9fee07c422602f0cfa2382e735b72f4b2fc628357d42acc90ee010b6d35c2e8e2

data/lib/specinfra/backend/base.rb

@@ -1,26 +1,12 @@
 require 'singleton'
 require 'specinfra/command_result'
 
-module Specinfra
-  module Backend
-    class Base
-      include Singleton
+module Specinfra::Backend
+  class Base
+    include Singleton
 
-      def set_example(e)
-        @example = e
-      end
-
-      def check_zero(cmd, *args)
-        run_command(Specinfra.command.send(cmd, *args)).success?
-      end
-
-      def method_missing(meth, *args, &block)
-        if meth.to_s =~ /^check/
-          check_zero(meth, *args)
-        else
-          run_command(Specinfra.command.send(meth, *args))
-        end
-      end
+    def set_example(e)
+      @example = e
     end
   end
 end

data/lib/specinfra/backend/docker.rb

@@ -1,69 +1,67 @@
-module Specinfra
-  module Backend
-    class Docker < Exec
-      def initialize
-        begin
-          require 'docker' unless defined?(::Docker)
-        rescue LoadError
-          fail "Docker client library is not available. Try installing `docker-api' gem."
-        end
-
-        @images = []
-        ::Docker.url = Specinfra.configuration.docker_url
+module Specinfra::Backend
+  class Docker < Exec
+    def initialize
+      begin
+        require 'docker' unless defined?(::Docker)
+      rescue LoadError
+        fail "Docker client library is not available. Try installing `docker-api' gem."
       end
 
-      def run_command(cmd, opts={})
-        cmd = build_command(cmd)
-        cmd = add_pre_command(cmd)
-        docker_run!(cmd)
-      end
+      @images = []
+      ::Docker.url = Specinfra.configuration.docker_url
+    end
 
-      def build_command(cmd)
-        cmd
-      end
+    def run_command(cmd, opts={})
+      cmd = build_command(cmd)
+      cmd = add_pre_command(cmd)
+      docker_run!(cmd)
+    end
 
-      def add_pre_command(cmd)
-        cmd
-      end
+    def build_command(cmd)
+      cmd
+    end
 
-      def copy_file(from, to)
-        @images << current_image.insert_local('localPath' => from, 'outputPath' => to)
-      end
+    def add_pre_command(cmd)
+      cmd
+    end
 
-      private
+    def copy_file(from, to)
+      @images << current_image.insert_local('localPath' => from, 'outputPath' => to)
+    end
 
-      def base_image
-        @base_image ||= ::Docker::Image.get(Specinfra.configuration.docker_image)
-      end
+    private
 
-      def current_image
-        @images.last || base_image
-      end
+    def base_image
+      @base_image ||= ::Docker::Image.get(Specinfra.configuration.docker_image)
+    end
 
-      def docker_run!(cmd, opts={})
-        opts = {
-          'Image' => current_image.id,
-          'Cmd' => %W{/bin/sh -c #{cmd}},
-        }.merge(opts)
+    def current_image
+      @images.last || base_image
+    end
 
-        if path = Specinfra::configuration::path
-          (opts['Env'] ||= {})['PATH'] = path
-        end
+    def docker_run!(cmd, opts={})
+      opts = {
+        'Image' => current_image.id,
+        'Cmd' => %W{/bin/sh -c #{cmd}},
+      }.merge(opts)
+
+      if path = Specinfra::configuration::path
+        (opts['Env'] ||= {})['PATH'] = path
+      end
 
-        container = ::Docker::Container.create(opts)
+      container = ::Docker::Container.create(opts)
+      begin
+        container.start
         begin
-          container.start
-          begin
-            stdout, stderr = container.attach
-            result = container.wait
-            return CommandResult.new :stdout => stdout.join, :stderr => stderr.join,
-              :exit_status => result['StatusCode']
-          rescue
-            container.kill
-          end
-        ensure
-          container.delete
+          stdout, stderr = container.attach
+          result = container.wait
+          return CommandResult.new :stdout => stdout.join, :stderr => stderr.join,
+            :exit_status => result['StatusCode']
+        rescue
+          container.kill
         end
+      ensure
+        container.delete
       end
     end
   end

data/lib/specinfra/backend/dockerfile.rb

@@ -1,21 +1,19 @@
-module Specinfra
-  module Backend
-    class Dockerfile < Specinfra::Backend::Base
-      def initialize
-        @lines = []
-        ObjectSpace.define_finalizer(self) {
-          File.write("Dockerfile", @lines.join("\n"))
-        }
-      end
+module Specinfra::Backend
+  class Dockerfile < Specinfra::Backend::Base
+    def initialize
+      @lines = []
+      ObjectSpace.define_finalizer(self) {
+        File.write("Dockerfile", @lines.join("\n"))
+      }
+    end
 
-      def run_command(cmd, opts={})
-        @lines << "RUN #{cmd}"
-        CommandResult.new
-      end
+    def run_command(cmd, opts={})
+      @lines << "RUN #{cmd}"
+      CommandResult.new
+    end
 
-      def from(base)
-        @lines << "FROM #{base}"
-      end
+    def from(base)
+      @lines << "FROM #{base}"
     end
   end
 end

data/lib/specinfra/backend/exec.rb

@@ -2,76 +2,74 @@ require 'singleton'
 require 'fileutils'
 require 'shellwords'
 
-module Specinfra
-  module Backend
-    class Exec < Base
+module Specinfra::Backend
+  class Exec < Base
 
-      def run_command(cmd, opts={})
-        cmd = build_command(cmd)
-        cmd = add_pre_command(cmd)
-        stdout = with_env do
-          `#{build_command(cmd)} 2>&1`
-        end
-        # In ruby 1.9, it is possible to use Open3.capture3, but not in 1.8
-        # stdout, stderr, status = Open3.capture3(cmd)
-
-        if @example
-          @example.metadata[:command] = cmd
-          @example.metadata[:stdout]  = stdout
-        end
+    def run_command(cmd, opts={})
+      cmd = build_command(cmd)
+      cmd = add_pre_command(cmd)
+      stdout = with_env do
+        `#{build_command(cmd)} 2>&1`
+      end
+      # In ruby 1.9, it is possible to use Open3.capture3, but not in 1.8
+      # stdout, stderr, status = Open3.capture3(cmd)
 
-        CommandResult.new :stdout => stdout, :exit_status => $?.exitstatus
+      if @example
+        @example.metadata[:command] = cmd
+        @example.metadata[:stdout]  = stdout
       end
 
-      def with_env
-        keys = %w[BUNDLER_EDITOR BUNDLE_BIN_PATH BUNDLE_GEMFILE
-          RUBYOPT GEM_HOME GEM_PATH GEM_CACHE]
+      CommandResult.new :stdout => stdout, :exit_status => $?.exitstatus
+    end
 
-        keys.each { |key| ENV["_SPECINFRA_#{key}"] = ENV[key] ; ENV.delete(key) }
+    def with_env
+      keys = %w[BUNDLER_EDITOR BUNDLE_BIN_PATH BUNDLE_GEMFILE
+          RUBYOPT GEM_HOME GEM_PATH GEM_CACHE]
 
-        env = Specinfra.configuration.env || {}
-        env[:LANG] ||= 'C'
+      keys.each { |key| ENV["_SPECINFRA_#{key}"] = ENV[key] ; ENV.delete(key) }
 
-        env.each do |key, value|
-          key = key.to_s
-          ENV["_SPECINFRA_#{key}"] = ENV[key];
-          ENV[key] = value
-        end
+      env = Specinfra.configuration.env || {}
+      env[:LANG] ||= 'C'
 
-        yield
-      ensure
-        keys.each { |key| ENV[key] = ENV.delete("_SPECINFRA_#{key}") }
-        env.each do |key, value|
-          key = key.to_s
-          ENV[key] = ENV.delete("_SPECINFRA_#{key}");
-        end
+      env.each do |key, value|
+        key = key.to_s
+        ENV["_SPECINFRA_#{key}"] = ENV[key];
+        ENV[key] = value
       end
 
-      def build_command(cmd)
-        shell = Specinfra.configuration.shell || '/bin/sh'
-        cmd = cmd.shelljoin if cmd.is_a?(Array)
-        cmd = "#{shell.shellescape} -c #{cmd.shellescape}"
+      yield
+    ensure
+      keys.each { |key| ENV[key] = ENV.delete("_SPECINFRA_#{key}") }
+      env.each do |key, value|
+        key = key.to_s
+        ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+      end
+    end
 
-        path = Specinfra.configuration.path
-        if path
-          cmd = %Q{env PATH="#{path}" #{cmd}}
-        end
+    def build_command(cmd)
+      shell = Specinfra.configuration.shell || '/bin/sh'
+      cmd = cmd.shelljoin if cmd.is_a?(Array)
+      cmd = "#{shell.shellescape} -c #{cmd.shellescape}"
 
-        cmd
+      path = Specinfra.configuration.path
+      if path
+        cmd = %Q{env PATH="#{path}" #{cmd}}
       end
 
-      def add_pre_command(cmd)
-        if Specinfra.configuration.pre_command
-          pre_cmd = build_command(Specinfra.configuration.pre_command)
-          "#{pre_cmd} && #{cmd}"
-        else
-          cmd
-        end
-      end
+      cmd
+    end
 
-      def copy_file(from, to)
-        FileUtils.cp(from, to)
+    def add_pre_command(cmd)
+      if Specinfra.configuration.pre_command
+        pre_cmd = build_command(Specinfra.configuration.pre_command)
+        "#{pre_cmd} && #{cmd}"
+      else
+        cmd
       end
     end
+
+    def copy_file(from, to)
+      FileUtils.cp(from, to)
+    end
   end
 end

data/lib/specinfra/backend/lxc.rb

@@ -1,42 +1,40 @@
-module Specinfra
-  module Backend
-    class Lxc < Exec
-      def initialize
-        begin
-          require 'lxc/extra' unless defined?(::LXC::Extra)
-        rescue LoadError
-          fail "LXC client library is not available. Try installing `lxc-extra' gem"
-        end
+module Specinfra::Backend
+  class Lxc < Exec
+    def initialize
+      begin
+        require 'lxc/extra' unless defined?(::LXC::Extra)
+      rescue LoadError
+        fail "LXC client library is not available. Try installing `lxc-extra' gem"
       end
+    end
 
-      def run_command(cmd, opts={})
-        cmd = build_command(cmd)
-        cmd = add_pre_command(cmd)
-        out, ret = ct.execute do
-          out = `#{cmd}  2>&1`
-          [out, $?.dup]
-        end
-        if @example
-          @example.metadata[:command] = cmd
-          @example.metadata[:stdout]  = out
-        end
-        CommandResult.new :stdout => out, :exit_status => ret.exitstatus
+    def run_command(cmd, opts={})
+      cmd = build_command(cmd)
+      cmd = add_pre_command(cmd)
+      out, ret = ct.execute do
+        out = `#{cmd}  2>&1`
+        [out, $?.dup]
       end
-      def build_command(cmd)
-        cmd
+      if @example
+        @example.metadata[:command] = cmd
+        @example.metadata[:stdout]  = out
       end
+      CommandResult.new :stdout => out, :exit_status => ret.exitstatus
+    end
+    def build_command(cmd)
+      cmd
+    end
 
-      def add_pre_command(cmd)
-        cmd
-      end
+    def add_pre_command(cmd)
+      cmd
+    end
 
-      def copy_file(from, to)
-        FileUtils.cp(from, File.join(ct.config_item('lxc.rootfs'), to))
-      end
+    def copy_file(from, to)
+      FileUtils.cp(from, File.join(ct.config_item('lxc.rootfs'), to))
+    end
 
-      def ct
-        @ct ||= ::LXC::Container.new(Specinfra.configuration.lxc)
-      end
+    def ct
+      @ct ||= ::LXC::Container.new(Specinfra.configuration.lxc)
     end
   end
 end

data/lib/specinfra/backend/shellscript.rb

@@ -1,27 +1,25 @@
 require 'singleton'
 
-module Specinfra
-  module Backend
-    class ShellScript < Base
-      def initialize
-        @lines = [ "#!/bin/sh", "" ]
-        ObjectSpace.define_finalizer(self, Writer.new("spec.sh", @lines))
-      end
+module Specinfra::Backend
+  class ShellScript < Base
+    def initialize
+      @lines = [ "#!/bin/sh", "" ]
+      ObjectSpace.define_finalizer(self, Writer.new("spec.sh", @lines))
+    end
 
-      def run_command(cmd, opts={})
-        @lines << cmd
-        CommandResult.new
-      end
+    def run_command(cmd, opts={})
+      @lines << cmd
+      CommandResult.new
+    end
 
-      class Writer
-        def initialize(file, lines)
-          @file = file
-          @lines = lines
-        end
+    class Writer
+      def initialize(file, lines)
+        @file = file
+        @lines = lines
+      end
 
-        def call(*args)
-          File.write(@file, @lines.join("\n"))
-        end
+      def call(*args)
+        File.write(@file, @lines.join("\n"))
       end
     end
   end

data/lib/specinfra/backend/ssh.rb

@@ -1,155 +1,154 @@
 require 'specinfra/backend/exec'
 require 'net/ssh'
 require 'net/scp'
-module Specinfra
-  module Backend
-    class Ssh < Exec
-      def prompt
-        'Password: '
-      end
 
-      def run_command(cmd, opt={})
-        cmd = build_command(cmd)
-        cmd = add_pre_command(cmd)
-        ret = with_env do
-          ssh_exec!(cmd)
-        end
+module Specinfra::Backend
+  class Ssh < Exec
+    def prompt
+      'Password: '
+    end
 
-        ret[:stdout].gsub!(/\r\n/, "\n")
+    def run_command(cmd, opt={})
+      cmd = build_command(cmd)
+      cmd = add_pre_command(cmd)
+      ret = with_env do
+        ssh_exec!(cmd)
+      end
 
-        if @example
-          @example.metadata[:command] = cmd
-          @example.metadata[:stdout]  = ret[:stdout]
-        end
+      ret[:stdout].gsub!(/\r\n/, "\n")
 
-        CommandResult.new ret
+      if @example
+        @example.metadata[:command] = cmd
+        @example.metadata[:stdout]  = ret[:stdout]
       end
 
-      def with_env
-        env = Specinfra.configuration.env || {}
-        env[:LANG] ||= 'C'
+      CommandResult.new ret
+    end
 
-        ssh_options = Specinfra.configuration.ssh_options || {}
-        ssh_options[:send_env] ||= []
+    def with_env
+      env = Specinfra.configuration.env || {}
+      env[:LANG] ||= 'C'
 
-        env.each do |key, value|
-          key = key.to_s
-          ENV["_SPECINFRA_#{key}"] = ENV[key];
-          ENV[key] = value
-          ssh_options[:send_env] << key
-        end
+      ssh_options = Specinfra.configuration.ssh_options || {}
+      ssh_options[:send_env] ||= []
 
-        yield
-      ensure
-        env.each do |key, value|
-          key = key.to_s
-          ENV[key] = ENV.delete("_SPECINFRA_#{key}");
-        end
+      env.each do |key, value|
+        key = key.to_s
+        ENV["_SPECINFRA_#{key}"] = ENV[key];
+        ENV[key] = value
+        ssh_options[:send_env] << key
       end
 
-      def build_command(cmd)
-        cmd = super(cmd)
-        user = Specinfra.configuration.ssh_options[:user]
-        disable_sudo = Specinfra.configuration.disable_sudo
-        if user != 'root' && !disable_sudo
-          cmd = "#{sudo} -p '#{prompt}' #{cmd}"
-        end
-        cmd
+      yield
+    ensure
+      env.each do |key, value|
+        key = key.to_s
+        ENV[key] = ENV.delete("_SPECINFRA_#{key}");
       end
+    end
 
-      def copy_file(from, to)
-        if Specinfra.configuration.scp.nil?
-          Specinfra.configuration.scp = create_scp
-        end
-
-        scp = Specinfra.configuration.scp
-        scp.upload!(from, to)
+    def build_command(cmd)
+      cmd = super(cmd)
+      user = Specinfra.configuration.ssh_options[:user]
+      disable_sudo = Specinfra.configuration.disable_sudo
+      if user != 'root' && !disable_sudo
+        cmd = "#{sudo} -p '#{prompt}' #{cmd}"
       end
+      cmd
+    end
 
-      private
-      def create_ssh
-        Net::SSH.start(
-          Specinfra.configuration.host,
-          Specinfra.configuration.ssh_options[:user],
-          Specinfra.configuration.ssh_options
-        )
+    def copy_file(from, to)
+      if Specinfra.configuration.scp.nil?
+        Specinfra.configuration.scp = create_scp
       end
 
-      def create_scp
-        ssh = Specinfra.configuration.ssh
-        if ssh.nil?
-          ssh = create_ssh
-        end
-        Net::SCP.new(ssh)
+      scp = Specinfra.configuration.scp
+      scp.upload!(from, to)
+    end
+
+    private
+    def create_ssh
+      Net::SSH.start(
+        Specinfra.configuration.host,
+        Specinfra.configuration.ssh_options[:user],
+        Specinfra.configuration.ssh_options
+      )
+    end
+
+    def create_scp
+      ssh = Specinfra.configuration.ssh
+      if ssh.nil?
+        ssh = create_ssh
       end
+      Net::SCP.new(ssh)
+    end
       
-      def ssh_exec!(command)
-        stdout_data = ''
-        stderr_data = ''
-        exit_status = nil
-        exit_signal = nil
-
-        if Specinfra.configuration.ssh.nil?
-          Specinfra.configuration.ssh = create_ssh
-        end
+    def ssh_exec!(command)
+      stdout_data = ''
+      stderr_data = ''
+      exit_status = nil
+      exit_signal = nil
+
+      if Specinfra.configuration.ssh.nil?
+        Specinfra.configuration.ssh = create_ssh
+      end
 
-        ssh = Specinfra.configuration.ssh
-        ssh.open_channel do |channel|
-          if Specinfra.configuration.sudo_password or Specinfra.configuration.request_pty
-            channel.request_pty do |ch, success|
-              abort "Could not obtain pty " if !success
-            end
+      ssh = Specinfra.configuration.ssh
+      ssh.open_channel do |channel|
+        if Specinfra.configuration.sudo_password or Specinfra.configuration.request_pty
+          channel.request_pty do |ch, success|
+            abort "Could not obtain pty " if !success
           end
-          channel.exec("#{command}") do |ch, success|
-            abort "FAILED: couldn't execute command (ssh.channel.exec)" if !success
-            channel.on_data do |ch, data|
-              if data.match /^#{prompt}/
-                channel.send_data "#{Specinfra.configuration.sudo_password}\n"
-              else
-                stdout_data += data
-              end
+        end
+        channel.exec("#{command}") do |ch, success|
+          abort "FAILED: couldn't execute command (ssh.channel.exec)" if !success
+          channel.on_data do |ch, data|
+            if data.match /^#{prompt}/
+              channel.send_data "#{Specinfra.configuration.sudo_password}\n"
+            else
+              stdout_data += data
             end
+          end
 
-            channel.on_extended_data do |ch, type, data|
-              if data.match /you must have a tty to run sudo/
-                abort 'Please set "Specinfra.configuration.request_pty = true" or "c.request_pty = true" in your spec_helper.rb or other appropriate file.'
-              end
-
-              if data.match /^sudo: no tty present and no askpass program specified/
-                abort "Please set sudo password by using SUDO_PASSWORD or ASK_SUDO_PASSWORD environment variable"
-              else
-                stderr_data += data
-              end
+          channel.on_extended_data do |ch, type, data|
+            if data.match /you must have a tty to run sudo/
+              abort 'Please set "Specinfra.configuration.request_pty = true" or "c.request_pty = true" in your spec_helper.rb or other appropriate file.'
             end
 
-            channel.on_request("exit-status") do |ch, data|
-              exit_status = data.read_long
+            if data.match /^sudo: no tty present and no askpass program specified/
+              abort "Please set sudo password by using SUDO_PASSWORD or ASK_SUDO_PASSWORD environment variable"
+            else
+              stderr_data += data
             end
+          end
 
-            channel.on_request("exit-signal") do |ch, data|
-              exit_signal = data.read_long
-            end
+          channel.on_request("exit-status") do |ch, data|
+            exit_status = data.read_long
           end
-        end
-        ssh.loop
-        { :stdout => stdout_data, :stderr => stderr_data, :exit_status => exit_status, :exit_signal => exit_signal }
-      end
 
-      def sudo
-        if sudo_path = Specinfra.configuration.sudo_path
-          sudo_path += '/sudo'
-        else
-          sudo_path = 'sudo'
+          channel.on_request("exit-signal") do |ch, data|
+            exit_signal = data.read_long
+          end
         end
+      end
+      ssh.loop
+      { :stdout => stdout_data, :stderr => stderr_data, :exit_status => exit_status, :exit_signal => exit_signal }
+    end
 
-        sudo_options = Specinfra.configuration.sudo_options
-        if sudo_options
-          sudo_options = sudo_options.shelljoin if sudo_options.is_a?(Array)
-          sudo_options = ' ' + sudo_options
-        end
+    def sudo
+      if sudo_path = Specinfra.configuration.sudo_path
+        sudo_path += '/sudo'
+      else
+        sudo_path = 'sudo'
+      end
 
-        "#{sudo_path.shellescape}#{sudo_options}"
+      sudo_options = Specinfra.configuration.sudo_options
+      if sudo_options
+        sudo_options = sudo_options.shelljoin if sudo_options.is_a?(Array)
+        sudo_options = ' ' + sudo_options
       end
+
+      "#{sudo_path.shellescape}#{sudo_options}"
     end
   end
 end

data/lib/specinfra/backend/winrm.rb

@@ -1,26 +1,23 @@
-module Specinfra
-  module Backend
-    class WinRM < Base
-      include PowerShell::ScriptHelper
+module Specinfra::Backend
+  class WinRM < Base
+    include PowerShell::ScriptHelper
 
-      def run_command(cmd, opts={})
-        script = create_script(cmd)
-        winrm = Specinfra.configuration.winrm
+    def run_command(cmd, opts={})
+      script = create_script(cmd)
+      winrm = Specinfra.configuration.winrm
 
-        result = winrm.powershell(script)
-        stdout, stderr = [:stdout, :stderr].map do |s|
-          result[:data].select {|item| item.key? s}.map {|item| item[s]}.join
-        end
-        result[:exitcode] = 1 if result[:exitcode] == 0 and !stderr.empty?
-
-        if @example
-          @example.metadata[:command] = script
-          @example.metadata[:stdout]  = stdout + stderr
-        end
+      result = winrm.powershell(script)
+      stdout, stderr = [:stdout, :stderr].map do |s|
+        result[:data].select {|item| item.key? s}.map {|item| item[s]}.join
+      end
+      result[:exitcode] = 1 if result[:exitcode] == 0 and !stderr.empty?
 
-        CommandResult.new :stdout => stdout, :stderr => stderr,
-          :exit_status => result[:exitcode]
+      if @example
+        @example.metadata[:command] = script
+        @example.metadata[:stdout]  = stdout + stderr
       end
+
+      CommandResult.new :stdout => stdout, :stderr => stderr, :exit_status => result[:exitcode]
     end
   end
 end

data/lib/specinfra/command/base.rb

@@ -20,7 +20,7 @@ class Specinfra::Command::Base
       Shellwords.shellescape(str)
     end
 
-    def method_missing(meth, *args)
+    def get(meth, *args)
       action, resource_type, subaction = breakdown(meth)
       method =  action
       method += "_#{subaction}" if subaction

data/lib/specinfra/command/base/file.rb

@@ -13,7 +13,7 @@ class Specinfra::Command::Base::File < Specinfra::Command::Base
     end
 
     def check_contains(file, expected_pattern)
-      "#{check_file_contains_with_regexp(file, expected_pattern)} || #{check_file_contains_with_fixed_strings(file, expected_pattern)}"
+      "#{check_contains_with_regexp(file, expected_pattern)} || #{check_contains_with_fixed_strings(file, expected_pattern)}"
     end
 
     def check_is_grouped(file, group)
@@ -35,8 +35,8 @@ class Specinfra::Command::Base::File < Specinfra::Command::Base
       from ||= '1'
       to ||= '$'
       sed = "sed -n #{escape(from)},#{escape(to)}p #{escape(file)}"
-      checker_with_regexp = check_file_contains_with_regexp("-", expected_pattern)
-      checker_with_fixed  = check_file_contains_with_fixed_strings("-", expected_pattern)
+      checker_with_regexp = check_contains_with_regexp("-", expected_pattern)
+      checker_with_fixed  = check_contains_with_fixed_strings("-", expected_pattern)
       "#{sed} | #{checker_with_regexp} || #{sed} | #{checker_with_fixed}"
     end
 

data/lib/specinfra/command/solaris/base/file.rb

@@ -4,8 +4,8 @@ class Specinfra::Command::Solaris::Base::File < Specinfra::Command::Base::File
       from ||= '1'
       to ||= '$'
       sed = "sed -n #{escape(from)},#{escape(to)}p #{escape(file)}"
-      checker_with_regexp = check_file_contains_with_regexp("/dev/stdin", expected_pattern)
-      checker_with_fixed  = check_file_contains_with_fixed_strings("/dev/stdin", expected_pattern)
+      checker_with_regexp = check_contains_with_regexp("/dev/stdin", expected_pattern)
+      checker_with_fixed  = check_contains_with_fixed_strings("/dev/stdin", expected_pattern)
       "#{sed} | #{checker_with_regexp} || #{sed} | #{checker_with_fixed}"
     end
 

data/lib/specinfra/helper/detect_os.rb

@@ -1,5 +1,8 @@
 module Specinfra::Helper
   class DetectOs
+    def self.run_command(cmd)
+      Specinfra.backend.run_command(cmd)
+    end
   end
 end
 

data/lib/specinfra/helper/os.rb

@@ -2,43 +2,20 @@ require 'specinfra/helper/detect_os'
 
 module Specinfra::Helper::Os
   def os
-    property[:os_by_host] = {} if ! property[:os_by_host]
-    host_port = current_host_and_port
-
-    if property[:os_by_host][host_port]
-      os_by_host = property[:os_by_host][host_port]
-    else
-      # Set command object explicitly to avoid `stack too deep`
-      os_by_host = detect_os
-      property[:os_by_host][host_port] = os_by_host
+    property[:os] = {} if ! property[:os]
+    if ! property[:os].include?(:family)
+      property[:os] = detect_os
     end
-    os_by_host
+    property[:os]
   end
 
   private
-
-  # put this in a module for better reuse
-  def current_host_and_port
-    if Specinfra.configuration.ssh
-      "#{Specinfra.configuration.ssh.host}:#{Specinfra.configuration.ssh.options[:port]}"
-    elsif Specinfra.configuration.ssh_options
-          
-      "#{Specinfra.configuration.host}:#{Specinfra.configuration.ssh_options[:port]}"
-    else
-      "#{Specinfra.configuration.host}:0"
-    end
-  end
-
-  def run_command(cmd)
-    Specinfra.backend.run_command(cmd)
-  end
-
   def detect_os
     return Specinfra.configuration.os if Specinfra.configuration.os
     Specinfra::Helper::DetectOs.subclasses.each do |c|
       res = c.detect
       if res
-        res[:arch] ||= run_command('uname -m').stdout.strip
+        res[:arch] ||= Specinfra.backend.run_command('uname -m').stdout.strip
         return res
       end
     end

data/lib/specinfra/processor.rb

@@ -1,11 +1,8 @@
 module Specinfra
   class Processor
-    def self.method_missing(meth, *args, &block)
-      Specinfra.backend.send(meth, *args)
-    end
-
     def self.check_service_is_running(service)
-      ret = Specinfra.backend.run_command(Specinfra.command.check_service_is_running(service))
+      cmd = Specinfra.command.get(:check_service_is_running, service)
+      ret = Specinfra.backend.run_command(cmd)
 
       # In Ubuntu, some services are under upstart and "service foo status" returns
       # exit status 0 even though they are stopped.
@@ -14,14 +11,16 @@ module Specinfra
 
       # If the service is not registered, check by ps command
       if ret.exit_status == 1
-        ret = Specinfra.backend.run_command(Specinfra.command.check_process_is_running(service))
+        cmd = Specinfra.command.get(:check_process_is_running, service)
+        ret = Specinfra.backend.run_command(cmd)
       end
 
       ret.success?
     end
 
     def self.check_service_is_monitored_by_monit(process)
-      ret = Specinfra.backend.run_command(Specinfra.command.check_service_is_monitored_by_monit(process))
+      cmd = Specinfra.command.get(:check_service_is_monitored_by_monit, process)
+      ret = Specinfra.backend.run_command(cmd)
       return false unless ret.stdout != nil && ret.success?
 
       retlines = ret.stdout.split(/[\r\n]+/).map(&:strip)
@@ -32,7 +31,8 @@ module Specinfra
     end
 
     def self.check_file_is_readable(file, by_whom)
-      mode = sprintf('%04s',Specinfra.backend.run_command(Specinfra.command.get_file_mode(file)).stdout.strip)
+      cmd = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
       mode = mode.split('')
       mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
       case by_whom
@@ -48,7 +48,8 @@ module Specinfra
     end
 
     def self.check_file_is_writable(file, by_whom)
-      mode = sprintf('%04s',Specinfra.backend.run_command(Specinfra.command.get_file_mode(file)).stdout.strip)
+      cmd = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
       mode = mode.split('')
       mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
       case by_whom
@@ -64,7 +65,8 @@ module Specinfra
     end
 
     def self.check_file_is_executable(file, by_whom)
-      mode = sprintf('%04s',Specinfra.backend.run_command(Specinfra.command.get_file_mode(file)).stdout.strip)
+      cmd  = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
       mode = mode.split('')
       mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
       case by_whom
@@ -80,7 +82,8 @@ module Specinfra
     end
 
     def self.check_file_is_mounted(path, expected_attr, only_with)
-      ret = Specinfra.backend.run_command(Specinfra.command.check_file_is_mounted(path))
+      cmd = Specinfra.command.get(:check_file_is_mounted, path)
+      ret = Specinfra.backend.run_command(cmd)
       if expected_attr.nil? || ret.failure?
         return ret.success?
       end
@@ -114,7 +117,8 @@ module Specinfra
 
     def self.check_routing_table_has_entry(expected_attr)
       return false if ! expected_attr[:destination]
-      ret = Specinfra.backend.get_routing_table_entry(expected_attr[:destination])
+      cmd = Specinfra.command.get(:get_routing_table_entry, expected_attr[:destination])
+      ret = Specinfra.backend.run_command(cmd)
       return false if ret.failure?
 
       ret.stdout.gsub!(/\r\n/, "\n")

data/lib/specinfra/runner.rb

@@ -1,11 +1,34 @@
 module Specinfra
   class Runner
-    def self.method_missing(meth, *args, &block)
+    def self.method_missing(meth, *args)
       if os.include?(:family) && os[:family] == 'windows'
-        Specinfra.backend.send(meth, *args)
+        run(meth, *args)
       else
-        Specinfra::Processor.send(meth, *args)
+        processor = Specinfra::Processor
+        backend   = Specinfra.backend
+        if processor.respond_to?(meth)
+          processor.send(meth, *args)
+        elsif backend.respond_to?(meth)
+          backend.send(meth, *args)
+        else
+          run(meth, *args)
+        end
       end
     end
+
+    def self.run_command(cmd)
+      Specinfra.backend.run_command(cmd)
+    end
+
+    private
+    def self.run(meth, *args)
+      cmd = Specinfra.command.get(meth, *args)
+      if meth.to_s =~ /^check/
+        Specinfra.backend.run_command(cmd).success?
+      else
+        Specinfra.backend.run_command(cmd)
+      end
+    end
+
   end
 end

data/lib/specinfra/version.rb

@@ -1,3 +1,3 @@
 module Specinfra
-  VERSION = "2.0.0.beta31"
+  VERSION = "2.0.0.beta32"
 end

data/spec/backend/exec/build_command_spec.rb

@@ -99,6 +99,9 @@ describe 'os' do
   end
 
   context 'test ubuntu with /etc/lsb-release' do
+    before do
+      property[:os] = nil
+    end
     subject { os }
     it do
       expect(Specinfra.backend).to receive(:run_command).at_least(1).times do |args|
@@ -124,6 +127,9 @@ EOF
   end
 
   context 'test debian (no lsb_release or lsb-release)' do
+    before do
+      property[:os] = nil
+    end
     subject { os }
     it do
       expect(Specinfra.backend).to receive(:run_command).at_least(1).times do |args|

data/spec/command/base/file_spec.rb

@@ -7,35 +7,35 @@ describe 'File related commands'  do
     property[:os_by_host] = nil
   end
 
-  context Specinfra.command.check_file_is_directory('/tmp') do
+  context Specinfra.command.get(:check_file_is_directory, '/tmp') do
     it { should eq 'test -d /tmp' }
   end
 
-  context Specinfra.command.change_file_mode('/tmp', '0644') do
+  context Specinfra.command.get(:change_file_mode, '/tmp', '0644') do
     it { should eq 'chmod 0644 /tmp' }
   end
 
-  context Specinfra.command.change_file_owner('/tmp', 'root') do
+  context Specinfra.command.get(:change_file_owner, '/tmp', 'root') do
     it { should eq 'chown root /tmp' }
   end
 
-  context Specinfra.command.change_file_owner('/tmp', 'root', 'root') do
+  context Specinfra.command.get(:change_file_owner, '/tmp', 'root', 'root') do
     it { should eq 'chown root:root /tmp' }
   end
 
-  context Specinfra.command.change_file_group('/tmp', 'root') do
+  context Specinfra.command.get(:change_file_group, '/tmp', 'root') do
     it { should eq 'chgrp root /tmp' }
   end
 
-  context Specinfra.command.create_file_as_directory('/tmp') do
+  context Specinfra.command.get(:create_file_as_directory, '/tmp') do
     it { should eq 'mkdir -p /tmp' }
   end
 
-  context Specinfra.command.get_file_owner_user('/tmp') do
+  context Specinfra.command.get(:get_file_owner_user, '/tmp') do
     it { should eq 'stat -c %U /tmp' }
   end
 
-  context Specinfra.command.get_file_owner_group('/tmp') do
+  context Specinfra.command.get(:get_file_owner_group, '/tmp') do
     it { should eq 'stat -c %G /tmp' }
   end
 end

data/spec/command/base_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe 'create_command_class work correctly' do
-  after do
-    property[:os_by_host] = nil
+  before do
+    property[:os] = nil
   end
 
   context 'family: base, release: nil' do

data/spec/command/redhat/interface_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-property[:os_by_host] = {}
+property[:os] = nil
 set :os, { :family => 'redhat', :release => 7 }
 
 describe Specinfra.command.create_command_class('interface') do

data/spec/command/redhat/package_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-property[:os_by_host] = {}
+property[:os] = nil
 set :os, { :family => 'redhat' }
 
-describe  Specinfra.command.check_package_is_installed('httpd') do
+describe  Specinfra.command.get(:check_package_is_installed, 'httpd') do
   after do
-    property[:os_by_host] = nil
+    property[:os] = nil
   end
 
   it { should eq 'rpm -q httpd' }

data/spec/helper/os_spec.rb

@@ -6,44 +6,44 @@ end
 
 describe 'no ssh connection without cache' do
   before do
+    property[:os] = nil
     set_stub_chain(:ssh, nil)
     set_stub_chain(:ssh_options, nil)
     set_stub_chain(:host, 'localhost')
     set_stub_chain(:os, :family => 'redhat')
   end
 
-  it { expect(property[:os_by_host]).to eq nil }
   it { expect(os[:family]).to eq 'redhat' }
 end
 
 describe 'no ssh connection with cache' do
-  it { expect(property[:os_by_host]['localhost:0']).to eq(:family => 'redhat') }
+  it { expect(property[:os]).to eq(:family => 'redhat') }
 end
 
 describe 'ssh_options without cache' do
   before do
+    property[:os] = nil
     set_stub_chain(:ssh, nil)
     set_stub_chain(:ssh_options, :port => 22)
     set_stub_chain(:host, 'localhost')
     set_stub_chain(:os, :family => 'ubuntu')
   end
 
-  it { expect(property[:os_by_host]['localhost:22']).to eq nil }
   it { expect(os[:family]).to eq 'ubuntu' }
 end
 
 describe 'ssh_options with cache' do
-  it { expect(property[:os_by_host]['localhost:22']).to eq(:family => 'ubuntu') }
+  it { expect(property[:os]).to eq(:family => 'ubuntu') }
 end
 
 describe 'ssh_connection without cache' do
   before do
+    property[:os] = nil
     set_stub_chain([:ssh, :host], 'localhost')
     set_stub_chain([:ssh, :options], :port => 2222)
     set_stub_chain(:os, :family => 'nixos')
   end
 
-  it { expect(property[:os_by_host]['localhost:2222']).to eq nil }
   it { expect(os[:family]).to eq 'nixos' }
 end
 
@@ -54,5 +54,5 @@ describe 'ssh_connection wit cache' do
     set_stub_chain(:os, :family => 'nixos')
   end
 
-  it { expect(property[:os_by_host]['localhost:2222']).to eq(:family => 'nixos') }
+  it { expect(property[:os]).to eq(:family => 'nixos') }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: specinfra
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta31
+  version: 2.0.0.beta32
 platform: ruby
 authors:
 - Gosuke Miyashita
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-10 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh