specinfra-cisco 2.40.2

data/lib/specinfra/backend/docker.rb

@@ -0,0 +1,112 @@
+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
+
+      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 add_pre_command(cmd)
+        cmd
+      end
+
+      def send_file(from, to)
+        if @base_image.nil?
+          fail 'Cannot call send_file without docker_image.'
+        end
+
+        @images << current_image.insert_local('localPath' => from, 'outputPath' => to)
+        cleanup_container
+        create_and_start_container
+      end
+
+      def commit_container
+        @container.commit
+      end
+
+      private
+
+      def create_and_start_container
+        opts = { 'Image' => current_image.id }
+
+        if current_image.json["Config"]["Cmd"].nil? && current_image.json["Config"]["Entrypoint"].nil?
+          opts.merge!({'Cmd' => ['/bin/sh']})
+        end
+
+        opts.merge!({'OpenStdin' => true})
+
+        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)
+
+        opts.merge!(get_config(:docker_container_create_options) || {})
+
+        @container = ::Docker::Container.create(opts)
+        @container.start
+      end
+
+      def cleanup_container
+        @container.stop
+        @container.delete
+      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 get_or_pull_image(name)
+        begin
+          ::Docker::Image.get(name)
+        rescue ::Docker::Error::NotFoundError
+          ::Docker::Image.create('fromImage' => name)
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/backend/dockerfile.rb

@@ -0,0 +1,32 @@
+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
+
+      def run_command(cmd, opts={})
+        @lines << "RUN #{cmd}"
+        CommandResult.new
+      end
+
+      def send_file(from, to)
+        @lines << "ADD #{from} #{to}"
+        CommandResult.new
+      end
+
+      def from(base)
+        @lines << "FROM #{base}"
+      end
+    end
+  end
+end

data/lib/specinfra/backend/exec.rb

@@ -0,0 +1,152 @@
+require 'singleton'
+require 'fileutils'
+require 'shellwords'
+require 'sfl'
+
+module Specinfra
+  module Backend
+    class Exec < Base
+      def run_command(cmd, opts={})
+        cmd = build_command(cmd)
+        cmd = add_pre_command(cmd)
+        stdout, stderr, exit_status = with_env do
+          spawn_command(cmd)
+        end
+
+        if @example
+          @example.metadata[:command] = cmd
+          @example.metadata[:stdout]  = stdout
+        end
+
+        CommandResult.new :stdout => stdout, :stderr => stderr, :exit_status => exit_status
+      end
+
+      def send_file(from, to)
+        FileUtils.cp(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}"
+
+        path = get_config(:path)
+        if path
+          cmd = %Q{env PATH="#{path}" #{cmd}}
+        end
+
+        cmd
+      end
+
+      private
+      def spawn_command(cmd)
+        stdout, stderr = '', ''
+        begin
+          quit_r, quit_w = IO.pipe
+          out_r,  out_w  = IO.pipe
+          err_r,  err_w  = IO.pipe
+
+          th = Thread.new do
+            output = {
+              quit_r => "",
+              out_r => "",
+              err_r => ""
+            }
+
+            handlers = {
+              quit_r => nil,
+              out_r => @stdout_handler,
+              err_r => @stderr_handler
+            }
+
+            begin
+              loop do
+                readable_ios, = IO.select(output.keys)
+
+                readable_ios.each do |fd|
+                  loop do
+                    begin
+                      out = fd.read_nonblock(4096)
+                      output[fd] << out
+
+                      handlers[fd].call(out) if handlers[fd]
+                    rescue Errno::EAGAIN
+                      # Ruby 2.2 has more specific exception class IO::EAGAINWaitReadable
+                      break
+                    end
+                  end
+                end
+
+                break unless output[quit_r].empty?
+              end
+            rescue EOFError
+            ensure
+              stdout = output[out_r]
+              stderr = output[err_r]
+              quit_r.close unless quit_r.closed?
+              out_r.close  unless out_r.closed?
+              err_r.close  unless err_r.closed?
+            end
+          end
+
+          th.abort_on_exception = true
+
+          pid = spawn(cmd, :out => out_w, :err => err_w)
+
+          out_w.close
+          err_w.close
+
+          pid, stats = Process.waitpid2(pid)
+
+          begin
+            quit_w.syswrite 1
+          rescue Errno::EPIPE
+          end
+
+          th.value # wait
+        ensure
+          quit_w.close unless quit_w.closed?
+        end
+
+        return stdout, stderr, stats.exitstatus
+      end
+
+      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) }
+
+        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
+
+        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
+
+      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
+end

data/lib/specinfra/backend/lxc.rb

@@ -0,0 +1,45 @@
+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"
+        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
+      end
+
+      def build_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 ct
+        @ct ||= ::LXC::Container.new(get_config(:lxc))
+      end
+    end
+  end
+end

data/lib/specinfra/backend/powershell/command.rb

@@ -0,0 +1,40 @@
+module Specinfra
+  module Backend
+    module PowerShell
+      class Command
+        attr_reader :import_functions, :script
+        def initialize &block
+          @import_functions = []
+          @script = ""
+          instance_eval &block if block_given?
+        end
+
+        def using *functions
+          functions.each { |f| import_functions << f }
+        end
+
+        def exec code
+          @script = code
+        end
+
+        def convert_regexp(target)
+          case target
+          when Regexp
+            target.source
+          else
+            target.to_s.gsub '/', ''
+          end
+        end
+
+        def get_identity id
+          raise "You must provide a specific Windows user/group" if id =~ /(owner|group|others)/
+          identity = id || 'Everyone'
+        end
+
+        def to_s
+          @script
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/backend/powershell/script_helper.rb

@@ -0,0 +1,86 @@
+require 'base64'
+
+module Specinfra
+  module Backend
+    module PowerShell
+      module ScriptHelper
+        def build_command(cmd)
+          path = get_config(:path)
+          if path
+            cmd.strip!
+            cmd = 
+<<-EOF
+$env:path = "#{path};$env:path"
+#{cmd}
+EOF
+          end
+          cmd
+        end
+
+        def add_pre_command(cmd)
+          path = get_config(:path)
+          if get_config(:pre_command)
+            cmd.strip!
+            cmd = 
+<<-EOF
+if (#{get_config(:pre_command)})
+{
+#{cmd}
+}
+EOF
+            cmd = "$env:path = \"#{path};$env:path\"\n#{cmd}" if path
+          end
+          cmd
+        end
+
+        def encode_script script
+          script_text = script.chars.to_a.join("\x00").chomp
+          script_text << "\x00" unless script_text[-1].eql? "\x00"
+          if script_text.respond_to?(:encode)
+            script_text = script_text.encode('ASCII-8BIT')
+          end
+          if Base64.respond_to?(:strict_encode64)
+            Base64.strict_encode64(script_text)
+          else
+            [ script_text ].pack("m").strip
+          end
+        end
+
+        def create_script command
+          if command.is_a? Command
+            ps_functions = command.import_functions.map { |f| File.read(File.join(File.dirname(__FILE__), 'support', f)) }
+            script = build_command(command.script)
+            script = add_pre_command(script)
+            <<-EOF
+$exitCode = 1
+$ProgressPreference = "SilentlyContinue"
+try {
+  #{ps_functions.join("\n")}
+  $success = (#{script})
+  if ($success -is [Boolean] -and $success) { $exitCode = 0 }
+} catch {
+  Write-Output $_.Exception.Message
+}
+Write-Output "Exiting with code: $exitCode"
+exit $exitCode
+          EOF
+          else
+            script = build_command(command.to_s)
+            add_pre_command(script)
+          end
+        end
+
+        def check_running(process)
+          ret = run_command(commands.check_running(process))
+
+          # If the service is not registered, check the process
+          if ret.exit_status == 1
+            ret = run_command(commands.check_process(process))
+          end
+
+          ret.success?
+        end
+      end
+    end
+  end
+end