specinfra 2.25.1 → 2.26.0

data/lib/specinfra/backend/ssh.rb

@@ -3,171 +3,173 @@ require 'specinfra/backend/exec'
 require 'net/ssh'
 require 'net/scp'
 
-module Specinfra::Backend
-  class Ssh < Exec
-    def run_command(cmd, opt={})
-      cmd = build_command(cmd)
-      cmd = add_pre_command(cmd)
-      ret = with_env do
-        ssh_exec!(cmd)
-      end
+module Specinfra
+  module Backend
+    class Ssh < Exec
+      def run_command(cmd, opt={})
+        cmd = build_command(cmd)
+        cmd = add_pre_command(cmd)
+        ret = with_env do
+          ssh_exec!(cmd)
+        end
 
-      ret[:stdout].gsub!(/\r\n/, "\n")
-      ret[:stdout].gsub!(/\A\n/, "") if sudo?
+        ret[:stdout].gsub!(/\r\n/, "\n")
+        ret[:stdout].gsub!(/\A\n/, "") if sudo?
 
-      if @example
-        @example.metadata[:command] = cmd
-        @example.metadata[:stdout]  = ret[:stdout]
-      end
+        if @example
+          @example.metadata[:command] = cmd
+          @example.metadata[:stdout]  = ret[:stdout]
+        end
 
-      CommandResult.new ret
-    end
+        CommandResult.new ret
+      end
 
-    def send_file(from, to)
-      scp_upload!(from, to)
-    end
+      def send_file(from, to)
+        scp_upload!(from, to)
+      end
 
-    def send_directory(from, to)
-      scp_upload!(from, to, :recursive => true)
-    end
+      def send_directory(from, to)
+        scp_upload!(from, to, :recursive => true)
+      end
 
-    def build_command(cmd)
-      cmd = super(cmd)
-      if sudo?
-        cmd = "#{sudo} -p '#{prompt}' #{cmd}"
+      def build_command(cmd)
+        cmd = super(cmd)
+        if sudo?
+          cmd = "#{sudo} -p '#{prompt}' #{cmd}"
+        end
+        cmd
       end
-      cmd
-    end
 
-    private
-    def prompt
-      'Password: '
-    end
+      private
+      def prompt
+        'Password: '
+      end
 
-    def with_env
-      env = get_config(:env) || {}
-      env[:LANG] ||= 'C'
+      def with_env
+        env = get_config(:env) || {}
+        env[:LANG] ||= 'C'
 
-      ssh_options = get_config(:ssh_options) || {}
-      ssh_options[:send_env] ||= []
+        ssh_options = get_config(:ssh_options) || {}
+        ssh_options[:send_env] ||= []
 
-      env.each do |key, value|
-        key = key.to_s
-        ENV["_SPECINFRA_#{key}"] = ENV[key];
-        ENV[key] = value
-        ssh_options[:send_env] << 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
 
-      yield
-    ensure
-      env.each do |key, value|
-        key = key.to_s
-        ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+        yield
+      ensure
+        env.each do |key, value|
+          key = key.to_s
+          ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+        end
       end
-    end
 
-    def create_ssh
-      Net::SSH.start(
-        get_config(:host),
-        get_config(:ssh_options)[:user],
-        get_config(:ssh_options)
-      )
-    end
-
-    def create_scp
-      ssh = get_config(:ssh)
-      if ssh.nil?
-        ssh = create_ssh
+      def create_ssh
+        Net::SSH.start(
+          get_config(:host),
+          get_config(:ssh_options)[:user],
+          get_config(:ssh_options)
+        )
       end
-      Net::SCP.new(ssh)
-    end
 
-    def scp_upload!(from, to, opt={})
-      if get_config(:scp).nil?
-        set_config(:scp, create_scp)
+      def create_scp
+        ssh = get_config(:ssh)
+        if ssh.nil?
+          ssh = create_ssh
+        end
+        Net::SCP.new(ssh)
       end
 
-      tmp = File.join('/tmp', File.basename(to))
-      scp = get_config(:scp)
-      scp.upload!(from, tmp, opt)
-      run_command(command.get(:move_file, tmp, to))
-    end
-
-    def ssh_exec!(command)
-      stdout_data = ''
-      stderr_data = ''
-      exit_status = nil
-      exit_signal = nil
-      retry_prompt = /^Sorry, try again/
+      def scp_upload!(from, to, opt={})
+        if get_config(:scp).nil?
+          set_config(:scp, create_scp)
+        end
 
-      if get_config(:ssh).nil?
-        set_config(:ssh, create_ssh)
+        tmp = File.join('/tmp', File.basename(to))
+        scp = get_config(:scp)
+        scp.upload!(from, tmp, opt)
+        run_command(command.get(:move_file, tmp, to))
       end
 
-      ssh = get_config(:ssh)
-      ssh.open_channel do |channel|
-        if get_config(:sudo_password) or get_config(:request_pty)
-          channel.request_pty do |ch, success|
-            abort "Could not obtain pty " if !success
-          end
+      def ssh_exec!(command)
+        stdout_data = ''
+        stderr_data = ''
+        exit_status = nil
+        exit_signal = nil
+        retry_prompt = /^Sorry, try again/
+
+        if get_config(:ssh).nil?
+          set_config(:ssh, create_ssh)
         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 retry_prompt
-              abort 'Wrong sudo password! Please confirm your password.'
-            elsif data.match /^#{prompt}/
-              channel.send_data "#{get_config(:sudo_password)}\n"
-            else
-              stdout_data += data
+
+        ssh = get_config(:ssh)
+        ssh.open_channel do |channel|
+          if get_config(:sudo_password) or get_config(:request_pty)
+            channel.request_pty do |ch, success|
+              abort "Could not obtain pty " if !success
             end
           end
-
-          channel.on_extended_data do |ch, type, data|
-            if data.match /you must have a tty to run sudo/
-              abort 'Please write "set :request_pty, true" in your spec_helper.rb or other appropriate file.'
+          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 retry_prompt
+                abort 'Wrong sudo password! Please confirm your password.'
+              elsif data.match /^#{prompt}/
+                channel.send_data "#{get_config(:sudo_password)}\n"
+              else
+                stdout_data += data
+              end
             end
 
-            if data.match /^sudo: no tty present and no askpass program specified/
-              abort 'Please set sudo password to Specinfra.configuration.sudo_password.'
-            else
-              stderr_data += data
+            channel.on_extended_data do |ch, type, data|
+              if data.match /you must have a tty to run sudo/
+                abort 'Please write "set :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 to Specinfra.configuration.sudo_password.'
+              else
+                stderr_data += data
+              end
             end
-          end
 
-          channel.on_request("exit-status") do |ch, data|
-            exit_status = data.read_long
-          end
+            channel.on_request("exit-status") do |ch, data|
+              exit_status = data.read_long
+            end
 
-          channel.on_request("exit-signal") do |ch, data|
-            exit_signal = data.read_long
+            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
-      ssh.loop
-      { :stdout => stdout_data, :stderr => stderr_data, :exit_status => exit_status, :exit_signal => exit_signal }
-    end
 
-    def sudo
-      if sudo_path = get_config(:sudo_path)
-        sudo_path += '/sudo'
-      else
-        sudo_path = 'sudo'
-      end
+      def sudo
+        if sudo_path = get_config(:sudo_path)
+          sudo_path += '/sudo'
+        else
+          sudo_path = 'sudo'
+        end
 
-      sudo_options = get_config(:sudo_options)
-      if sudo_options
-        sudo_options = sudo_options.shelljoin if sudo_options.is_a?(Array)
-        sudo_options = ' ' + sudo_options
-      end
+        sudo_options = get_config(: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
+        "#{sudo_path.shellescape}#{sudo_options}"
+      end
 
-    def sudo?
-      user = get_config(:ssh_options)[:user]
-      disable_sudo = get_config(:disable_sudo)
-      user != 'root' && !disable_sudo
+      def sudo?
+        user = get_config(:ssh_options)[:user]
+        disable_sudo = get_config(:disable_sudo)
+        user != 'root' && !disable_sudo
+      end
     end
   end
 end

data/lib/specinfra/backend/telnet.rb

@@ -2,108 +2,110 @@
 require 'specinfra/backend/exec'
 require 'net/telnet'
 
-module Specinfra::Backend
-  class Telnet < Exec
-    def run_command(cmd, opt={})
-      cmd = build_command(cmd)
-      cmd = add_pre_command(cmd)
-      ret = with_env do
-        telnet_exec!(cmd)
-      end
-      if @example
-        @example.metadata[:command] = cmd
-        @example.metadata[:stdout]  = ret[:stdout]
-      end
+module Specinfra
+  module Backend
+    class Telnet < Exec
+      def run_command(cmd, opt={})
+        cmd = build_command(cmd)
+        cmd = add_pre_command(cmd)
+        ret = with_env do
+          telnet_exec!(cmd)
+        end
+        if @example
+          @example.metadata[:command] = cmd
+          @example.metadata[:stdout]  = ret[:stdout]
+        end
 
-      CommandResult.new ret
-    end
+        CommandResult.new ret
+      end
 
-    def build_command(cmd)
-      cmd = super(cmd)
-      cmd
-    end
+      def build_command(cmd)
+        cmd = super(cmd)
+        cmd
+      end
 
-    private
-    def prompt
-      'Login: '
-    end
+      private
+      def prompt
+        'Login: '
+      end
 
-    def with_env
-      env = get_config(:env) || {}
-      env[:LANG] ||= 'C'
+      def with_env
+        env = get_config(:env) || {}
+        env[:LANG] ||= 'C'
 
-      env.each do |key, value|
-        key = key.to_s
-        ENV["_SPECINFRA_#{key}"] = ENV[key];
-        ENV[key] = value
-      end
+        env.each do |key, value|
+          key = key.to_s
+          ENV["_SPECINFRA_#{key}"] = ENV[key];
+          ENV[key] = value
+        end
 
-      yield
-    ensure
-      env.each do |key, value|
-        key = key.to_s
-        ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+        yield
+      ensure
+        env.each do |key, value|
+          key = key.to_s
+          ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+        end
       end
-    end
 
-    def add_pre_command(cmd)
-      if get_config(:pre_command)
-        pre_cmd = build_command(get_config(:pre_command))
-        "#{pre_cmd} && #{cmd}"
-      else
-        cmd
+      def add_pre_command(cmd)
+        if get_config(:pre_command)
+          pre_cmd = build_command(get_config(:pre_command))
+          "#{pre_cmd} && #{cmd}"
+        else
+          cmd
+        end
       end
-    end
 
-    def telnet_exec!( command )
-      stdout_data = ''
-      stderr_data = ''
-      exit_status = nil
-      exit_signal = nil
-      retry_prompt = /^Login: /
-      if get_config(:telnet).nil?
-        set_config(:telnet, create_telnet)
+      def telnet_exec!( command )
+        stdout_data = ''
+        stderr_data = ''
+        exit_status = nil
+        exit_signal = nil
+        retry_prompt = /^Login: /
+        if get_config(:telnet).nil?
+          set_config(:telnet, create_telnet)
+        end
+        telnet = get_config(:telnet)
+        re = [] 
+        unless telnet.nil?
+          re = telnet.cmd( "#{command}; echo $?" ).split("\n")[0..-2]
+          exit_status = re.last.to_i
+          stdout_data = re[1..-2].join("\n")
+        end
+        { :stdout => stdout_data, :stderr => stderr_data, :exit_status => exit_status, :exit_signal => exit_signal }
       end
-      telnet = get_config(:telnet)
-      re = [] 
-      unless telnet.nil?
-        re = telnet.cmd( "#{command}; echo $?" ).split("\n")[0..-2]
-        exit_status = re.last.to_i
-        stdout_data = re[1..-2].join("\n")
+   
+      def create_telnet
+        tel = Net::Telnet.new( "Host" => get_config(:host) )
+        tel.login( 
+          "Name" => get_config(:telnet_options)[:user], 
+          "Password" => get_config(:telnet_options)[:pass]
+        )
+        tel
+      rescue
+        return nil
       end
-      { :stdout => stdout_data, :stderr => stderr_data, :exit_status => exit_status, :exit_signal => exit_signal }
-    end
- 
-    def create_telnet
-      tel = Net::Telnet.new( "Host" => get_config(:host) )
-      tel.login( 
-        "Name" => get_config(:telnet_options)[:user], 
-        "Password" => get_config(:telnet_options)[:pass]
-      )
-      tel
-    rescue
-      return nil
-    end
 
-    def sudo
-      if sudo_path = get_config(:sudo_path)
-        sudo_path += '/sudo'
-      else
-        sudo_path = 'sudo'
-      end
+      def sudo
+        if sudo_path = get_config(:sudo_path)
+          sudo_path += '/sudo'
+        else
+          sudo_path = 'sudo'
+        end
+
+        sudo_options = get_config(:sudo_options)
+        if sudo_options
+          sudo_options = sudo_options.shelljoin if sudo_options.is_a?(Array)
+          sudo_options = ' ' + sudo_options
+        end
 
-      sudo_options = get_config(:sudo_options)
-      if sudo_options
-        sudo_options = sudo_options.shelljoin if sudo_options.is_a?(Array)
-        sudo_options = ' ' + sudo_options
+        "#{sudo_path.shellescape}#{sudo_options}"
       end
 
-      "#{sudo_path.shellescape}#{sudo_options}"
-    end
+      def sudo?
+        false
+      end
 
-    def sudo?
-      false
     end
-
   end
 end

data/lib/specinfra/backend/winrm.rb

@@ -1,24 +1,26 @@
-module Specinfra::Backend
-  class Winrm < Base
-    include PowerShell::ScriptHelper
+module Specinfra
+  module Backend
+    class Winrm < Base
+      include PowerShell::ScriptHelper
 
-    def run_command(cmd, opts={})
-      set_config(:os, {:family => 'windows'})
-      script = create_script(cmd)
-      winrm = get_config(:winrm)
+      def run_command(cmd, opts={})
+        set_config(:os, {:family => 'windows'})
+        script = create_script(cmd)
+        winrm = get_config(: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?
+        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
+        if @example
+          @example.metadata[:command] = script
+          @example.metadata[:stdout]  = stdout + stderr
+        end
 
-      CommandResult.new :stdout => stdout, :stderr => stderr, :exit_status => result[:exitcode]
+        CommandResult.new :stdout => stdout, :stderr => stderr, :exit_status => result[:exitcode]
+      end
     end
   end
 end

data/lib/specinfra/command/module/systemd.rb

@@ -1,40 +1,47 @@
-module Specinfra::Command::Module::Systemd
-  def check_is_enabled(service, level="multi-user.target")
-    if level.to_s =~ /^\d+$/
-      level = "runlevel#{level}.target"
+module Specinfra
+  module Command
+    module Module
+      module Systemd
+        def check_is_enabled(service, level="multi-user.target")
+          if level.to_s =~ /^\d+$/
+            level = "runlevel#{level}.target"
+          end
+          unless service.include?('.')
+            service += '.service'
+          end
+
+          "systemctl --plain list-dependencies #{level} | grep '\\(^\\| \\)#{escape(service)}$'"
+        end
+
+        def check_is_running(service)
+          "systemctl is-active #{escape(service)}"
+        end
+
+        def enable(service)
+          "systemctl enable #{escape(service)}"
+        end
+
+        def disable(service)
+          "systemctl disable #{escape(service)}"
+        end
+
+        def start(service)
+          "systemctl start #{escape(service)}"
+        end
+
+        def stop(service)
+          "systemctl stop #{escape(service)}"
+        end
+
+        def restart(service)
+          "systemctl restart #{escape(service)}"
+        end
+
+        def reload(service)
+          "systemctl reload #{escape(service)}"
+        end
+      end
     end
-    unless service.include?('.')
-      service += '.service'
-    end
-
-    "systemctl --plain list-dependencies #{level} | grep '\\(^\\| \\)#{escape(service)}$'"
-  end
-
-  def check_is_running(service)
-    "systemctl is-active #{escape(service)}"
-  end
-
-  def enable(service)
-    "systemctl enable #{escape(service)}"
-  end
-
-  def disable(service)
-    "systemctl disable #{escape(service)}"
-  end
-
-  def start(service)
-    "systemctl start #{escape(service)}"
-  end
-
-  def stop(service)
-    "systemctl stop #{escape(service)}"
-  end
-
-  def restart(service)
-    "systemctl restart #{escape(service)}"
-  end
-
-  def reload(service)
-    "systemctl reload #{escape(service)}"
   end
 end
+

data/lib/specinfra/command/module/zfs.rb

@@ -1,18 +1,25 @@
-module Specinfra::Command::Module::Zfs
-  def check_exists(zfs)
-      "zfs list -H #{escape(zfs)}"
-  end
+module Specinfra
+  module Command
+    module Module
+      module Zfs
+        def check_exists(zfs)
+            "zfs list -H #{escape(zfs)}"
+        end
 
-  def check_has_property(zfs, property=nil)
-    commands = []
-    property.sort.each do |key, value|
-      regexp = "^#{value}$"
-      commands << "zfs list -H -o #{escape(key)} #{escape(zfs)} | grep -- #{escape(regexp)}"
-    end
-    commands.join(' && ')
-  end
+        def check_has_property(zfs, property=nil)
+          commands = []
+          property.sort.each do |key, value|
+            regexp = "^#{value}$"
+            commands << "zfs list -H -o #{escape(key)} #{escape(zfs)} | grep -- #{escape(regexp)}"
+          end
+          commands.join(' && ')
+        end
 
-  def get_property(zfs)
-    "zfs get -Hp -o property,value all #{escape(zfs)}"
+        def get_property(zfs)
+          "zfs get -Hp -o property,value all #{escape(zfs)}"
+        end
+      end
+    end
   end
 end
+

data/lib/specinfra/command/module.rb

@@ -1,2 +1,7 @@
-module  Specinfra::Command::Module; end
+module Specinfra
+  module Command
+    module Module
+    end
+  end
+end