specinfra 2.25.1 → 2.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e39e8f07b3f3da79bf77e6467ac8f0eb5dd1843
-  data.tar.gz: b5381e5f994384571d7bb35a719fb010a43bf124
+  metadata.gz: d4aa147d96470a2427c0fa6e4935a0bb9d6f7b8c
+  data.tar.gz: 93a02c122359e5881ab9983cb7fce3cb34e78f5c
 SHA512:
-  metadata.gz: b7cccede663857165f03dd291b76b7a1f21efbed985bb77827545ec3042335a1beed234556b65563d8927346e9ed853aa0ee4e3d3e4f68ca154b9779cfa54580
-  data.tar.gz: a2c1f1d6d8b04c0897f62ce332676fe89800846428432a09f680860126d5249171ab407280a8317ce66cda404ce9213e7ca0c4e29ee5daa23724b931ecd9a847
+  metadata.gz: c581e6ffa5a7a7fa5bf00f5320a05a358d54fe0a61d2233bcdcef6acc37d1310365527b67967ae2d12c460d7ac17c4c2bd768721b8b1a5c662a35e98e2ddebbd
+  data.tar.gz: db718882e9224df3f6adef39d750c19d253cbc18ce1a39f1cda229c04455928f3247ed554c61c3d2d6725742b9fdd64f450734cd718cd30b700d161daa63e143

data/lib/specinfra/backend/base.rb

@@ -1,45 +1,47 @@
 require 'singleton'
 require 'specinfra/command_result'
 
-module Specinfra::Backend
-  class Base
-    def self.instance
-      @instance ||= self.new
-    end
+module Specinfra
+  module Backend
+    class Base
+      def self.instance
+        @instance ||= self.new
+      end
 
-    def initialize(config = {})
-      @config = config
-    end
+      def initialize(config = {})
+        @config = config
+      end
 
-    def get_config(key)
-      @config[key] || Specinfra.configuration.send(key)
-    end
+      def get_config(key)
+        @config[key] || Specinfra.configuration.send(key)
+      end
 
-    def set_config(key, value)
-      @config[key] = value
-    end
+      def set_config(key, value)
+        @config[key] = value
+      end
 
-    def os_info
-      return @os_info if @os_info
+      def os_info
+        return @os_info if @os_info
 
-      Specinfra::Helper::DetectOs.subclasses.each do |klass|
-        if @os_info = klass.new(self).detect
-          @os_info[:arch] ||= self.run_command('uname -m').stdout.strip
-          return @os_info
+        Specinfra::Helper::DetectOs.subclasses.each do |klass|
+          if @os_info = klass.new(self).detect
+            @os_info[:arch] ||= self.run_command('uname -m').stdout.strip
+            return @os_info
+          end
         end
       end
-    end
 
-    def command
-      CommandFactory.new(os_info)
-    end
+      def command
+        CommandFactory.new(os_info)
+      end
 
-    def host_inventory
-      @inventory ||= HostInventory.new(self)
-    end
+      def host_inventory
+        @inventory ||= HostInventory.new(self)
+      end
 
-    def set_example(e)
-      @example = e
+      def set_example(e)
+        @example = e
+      end
     end
   end
 end

data/lib/specinfra/backend/docker.rb

@@ -1,109 +1,111 @@
-module Specinfra::Backend
-  class Docker < Exec
-    def initialize(config = {})
-      super
-
-      begin
-        require 'docker' unless defined?(::Docker)
-      rescue LoadError
-        fail "Docker client library is not available. Try installing `docker-api' gem."
+module Specinfra
+  module Backend
+    class Docker < Exec
+      def initialize(config = {})
+        super
+
+        begin
+          require 'docker' unless defined?(::Docker)
+        rescue LoadError
+          fail "Docker client library is not available. Try installing `docker-api' gem."
+        end
+
+        ::Docker.url = get_config(:docker_url)
+
+        if image = get_config(:docker_image)
+          @images = []
+          @base_image = get_or_pull_image(image)
+
+          create_and_start_container
+          ObjectSpace.define_finalizer(self, proc { cleanup_container })
+        elsif container = get_config(:docker_container)
+          @container = ::Docker::Container.get(container)
+        else
+          fail 'Please specify docker_image or docker_container.'
+        end
       end
 
-      ::Docker.url = get_config(:docker_url)
-
-      if image = get_config(:docker_image)
-        @images = []
-        @base_image = get_or_pull_image(image)
-
-        create_and_start_container
-        ObjectSpace.define_finalizer(self, proc { cleanup_container })
-      elsif container = get_config(:docker_container)
-        @container = ::Docker::Container.get(container)
-      else
-        fail 'Please specify docker_image or docker_container.'
+      def run_command(cmd, opts={})
+        cmd = build_command(cmd)
+        cmd = add_pre_command(cmd)
+        docker_run!(cmd)
       end
-    end
 
-    def run_command(cmd, opts={})
-      cmd = build_command(cmd)
-      cmd = add_pre_command(cmd)
-      docker_run!(cmd)
-    end
+      def build_command(cmd)
+        cmd
+      end
 
-    def build_command(cmd)
-      cmd
-    end
+      def add_pre_command(cmd)
+        cmd
+      end
 
-    def add_pre_command(cmd)
-      cmd
-    end
+      def send_file(from, to)
+        if @base_image.nil?
+          fail 'Cannot call send_file without docker_image.'
+        end
 
-    def send_file(from, to)
-      if @base_image.nil?
-        fail 'Cannot call send_file without docker_image.'
+        @images << current_image.insert_local('localPath' => from, 'outputPath' => to)
+        cleanup_container
+        create_and_start_container
       end
 
-      @images << current_image.insert_local('localPath' => from, 'outputPath' => to)
-      cleanup_container
-      create_and_start_container
-    end
-
-    def commit_container
-      @container.commit
-    end
+      def commit_container
+        @container.commit
+      end
 
-    private
+      private
 
-    def create_and_start_container
-      opts = { 'Image' => current_image.id }
+      def create_and_start_container
+        opts = { 'Image' => current_image.id }
 
-      if current_image.json["Config"]["Cmd"].nil?
-        opts.merge!({'Cmd' => ['/bin/sh']})
-      end
+        if current_image.json["Config"]["Cmd"].nil?
+          opts.merge!({'Cmd' => ['/bin/sh']})
+        end
 
-      opts.merge!({'OpenStdin' => true})
+        opts.merge!({'OpenStdin' => true})
 
-      if path = get_config(:path)
-        (opts['Env'] ||= []) << "PATH=#{path}"
-      end
+        if path = get_config(:path)
+          (opts['Env'] ||= []) << "PATH=#{path}"
+        end
 
-      env = get_config(:env).to_a.map { |v| v.join('=') }
-      opts['Env'] = opts['Env'].to_a.concat(env)
+        env = get_config(:env).to_a.map { |v| v.join('=') }
+        opts['Env'] = opts['Env'].to_a.concat(env)
 
-      opts.merge!(get_config(:docker_container_create_options) || {})
+        opts.merge!(get_config(:docker_container_create_options) || {})
 
-      @container = ::Docker::Container.create(opts)
-      @container.start
-    end
+        @container = ::Docker::Container.create(opts)
+        @container.start
+      end
 
-    def cleanup_container
-      @container.stop
-      @container.delete
-    end
+      def cleanup_container
+        @container.stop
+        @container.delete
+      end
 
-    def current_image
-      @images.last || @base_image
-    end
+      def current_image
+        @images.last || @base_image
+      end
 
-    def docker_run!(cmd, opts={})
-      stdout, stderr, status = @container.exec(['/bin/sh', '-c', cmd])
-
-      CommandResult.new :stdout => stdout.join, :stderr => stderr.join,
-      :exit_status => status
-    rescue ::Docker::Error::DockerError => e
-      raise
-    rescue => e
-      @container.kill
-      err = stderr.nil? ? ([e.message] + e.backtrace) : stderr
-      CommandResult.new :stdout => [stdout].join, :stderr => err.join,
-      :exit_status => (status || 1)
-    end
+      def docker_run!(cmd, opts={})
+        stdout, stderr, status = @container.exec(['/bin/sh', '-c', cmd])
+
+        CommandResult.new :stdout => stdout.join, :stderr => stderr.join,
+        :exit_status => status
+      rescue ::Docker::Error::DockerError => e
+        raise
+      rescue => e
+        @container.kill
+        err = stderr.nil? ? ([e.message] + e.backtrace) : stderr
+        CommandResult.new :stdout => [stdout].join, :stderr => err.join,
+        :exit_status => (status || 1)
+      end
 
-    def get_or_pull_image(name)
-      begin
-        ::Docker::Image.get(name)
-      rescue ::Docker::Error::NotFoundError
-        ::Docker::Image.create('fromImage' => name)
+      def get_or_pull_image(name)
+        begin
+          ::Docker::Image.get(name)
+        rescue ::Docker::Error::NotFoundError
+          ::Docker::Image.create('fromImage' => name)
+        end
       end
     end
   end

data/lib/specinfra/backend/dockerfile.rb

@@ -1,31 +1,32 @@
-# -*- coding: utf-8 -*-
-module Specinfra::Backend
-  class Dockerfile < Specinfra::Backend::Base
-    def initialize(config = {})
-      super
+module Specinfra
+  module Backend
+    class Dockerfile < Specinfra::Backend::Base
+      def initialize(config = {})
+        super
 
-      @lines = []
-      ObjectSpace.define_finalizer(self) {
-        if get_config(:dockerfile_finalizer).nil?
-          puts @lines
-        else
-          get_config(:dockerfile_finalizer).call(@lines)
-        end
-      }
-    end
+        @lines = []
+        ObjectSpace.define_finalizer(self) {
+          if get_config(:dockerfile_finalizer).nil?
+            puts @lines
+          else
+            get_config(:dockerfile_finalizer).call(@lines)
+          end
+        }
+      end
 
-    def run_command(cmd, opts={})
-      @lines << "RUN #{cmd}"
-      CommandResult.new
-    end
+      def run_command(cmd, opts={})
+        @lines << "RUN #{cmd}"
+        CommandResult.new
+      end
 
-    def send_file(from, to)
-      @lines << "ADD #{from} #{to}"
-      CommandResult.new
-    end
+      def send_file(from, to)
+        @lines << "ADD #{from} #{to}"
+        CommandResult.new
+      end
 
-    def from(base)
-      @lines << "FROM #{base}"
+      def from(base)
+        @lines << "FROM #{base}"
+      end
     end
   end
 end

data/lib/specinfra/backend/exec.rb

@@ -2,77 +2,79 @@ require 'singleton'
 require 'fileutils'
 require 'shellwords'
 
-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)
+module Specinfra
+  module 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
 
-      if @example
-        @example.metadata[:command] = cmd
-        @example.metadata[:stdout]  = stdout
+        CommandResult.new :stdout => stdout, :exit_status => $?.exitstatus
       end
 
-      CommandResult.new :stdout => stdout, :exit_status => $?.exitstatus
-    end
+      def send_file(from, to)
+        FileUtils.cp(from, to)
+      end
 
-    def send_file(from, to)
-      FileUtils.cp(from, to)
-    end
+      def send_directory(from, to)
+        FileUtils.cp_r(from, to)
+      end
 
-    def send_directory(from, to)
-      FileUtils.cp_r(from, to)
-    end
+      def build_command(cmd)
+        shell = get_config(:shell) || '/bin/sh'
+        cmd = cmd.shelljoin if cmd.is_a?(Array)
+        cmd = "#{shell.shellescape} -c #{cmd.to_s.shellescape}"
 
-    def build_command(cmd)
-      shell = get_config(:shell) || '/bin/sh'
-      cmd = cmd.shelljoin if cmd.is_a?(Array)
-      cmd = "#{shell.shellescape} -c #{cmd.to_s.shellescape}"
+        path = get_config(:path)
+        if path
+          cmd = %Q{env PATH="#{path}" #{cmd}}
+        end
 
-      path = get_config(:path)
-      if path
-        cmd = %Q{env PATH="#{path}" #{cmd}}
+        cmd
       end
 
-      cmd
-    end
-
-    private
-    def with_env
-      keys = %w[BUNDLER_EDITOR BUNDLE_BIN_PATH BUNDLE_GEMFILE
-          RUBYOPT GEM_HOME GEM_PATH GEM_CACHE]
+      private
+      def with_env
+        keys = %w[BUNDLER_EDITOR BUNDLE_BIN_PATH BUNDLE_GEMFILE
+            RUBYOPT GEM_HOME GEM_PATH GEM_CACHE]
 
-      keys.each { |key| ENV["_SPECINFRA_#{key}"] = ENV[key] ; ENV.delete(key) }
+        keys.each { |key| ENV["_SPECINFRA_#{key}"] = ENV[key] ; ENV.delete(key) }
 
-      env = get_config(:env) || {}
-      env[:LANG] ||= 'C'
+        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
-      keys.each { |key| ENV[key] = ENV.delete("_SPECINFRA_#{key}") }
-      env.each do |key, value|
-        key = key.to_s
-        ENV[key] = ENV.delete("_SPECINFRA_#{key}");
+        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
-    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
   end

data/lib/specinfra/backend/lxc.rb

@@ -1,43 +1,45 @@
-module Specinfra::Backend
-  class Lxc < Exec
-    def initialize(config = {})
-      super
+module Specinfra
+  module Backend
+    class Lxc < Exec
+      def initialize(config = {})
+        super
 
-      begin
-        require 'lxc/extra' unless defined?(::LXC::Extra)
-      rescue LoadError
-        fail "LXC client library is not available. Try installing `lxc-extra' gem"
+        begin
+          require 'lxc/extra' unless defined?(::LXC::Extra)
+        rescue LoadError
+          fail "LXC client library is not available. Try installing `lxc-extra' gem"
+        end
       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
+      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
       end
-      CommandResult.new :stdout => out, :exit_status => ret.exitstatus
-    end
 
-    def build_command(cmd)
-      cmd
-    end
+      def build_command(cmd)
+        cmd
+      end
 
-    def add_pre_command(cmd)
-      cmd
-    end
+      def add_pre_command(cmd)
+        cmd
+      end
 
-    def send_file(from, to)
-      FileUtils.cp(from, File.join(ct.config_item('lxc.rootfs'), to))
-    end
+      def send_file(from, to)
+        FileUtils.cp(from, File.join(ct.config_item('lxc.rootfs'), to))
+      end
 
-    def ct
-      @ct ||= ::LXC::Container.new(get_config(:lxc))
+      def ct
+        @ct ||= ::LXC::Container.new(get_config(:lxc))
+      end
     end
   end
 end

data/lib/specinfra/backend/shell_script.rb

@@ -1,26 +1,28 @@
 require 'singleton'
 
-module Specinfra::Backend
-  class ShellScript < Base
-    def initialize(config = {})
-      super
+module Specinfra
+  module Backend
+    class ShellScript < Base
+      def initialize(config = {})
+        super
 
-      @lines = [ "#!/bin/sh", "" ]
-      ObjectSpace.define_finalizer(self, Writer.new(@lines))
-    end
-
-    def run_command(cmd, opts={})
-      @lines << cmd
-      CommandResult.new
-    end
+        @lines = [ "#!/bin/sh", "" ]
+        ObjectSpace.define_finalizer(self, Writer.new(@lines))
+      end
 
-    class Writer
-      def initialize(lines)
-        @lines = lines
+      def run_command(cmd, opts={})
+        @lines << cmd
+        CommandResult.new
       end
 
-      def call(*args)
-        puts @lines
+      class Writer
+        def initialize(lines)
+          @lines = lines
+        end
+
+        def call(*args)
+          puts @lines
+        end
       end
     end
   end