chef-metal 0.14.2 → 0.15

data/lib/chef_metal/transport/winrm.rb

@@ -1,134 +1 @@
-require 'chef_metal/transport'
-require 'base64'
-require 'timeout'
-
-module ChefMetal
-  class Transport
-    class WinRM < ChefMetal::Transport
-      def initialize(endpoint, type, options, global_config)
-        @endpoint = endpoint
-        @type = type
-        @options = options
-        @config = global_config
-      end
-
-      attr_reader :endpoint
-      attr_reader :type
-      attr_reader :options
-      attr_reader :config
-
-      def execute(command, execute_options = {})
-        output = with_execute_timeout(execute_options) do
-          session.set_timeout(execute_timeout(execute_options))
-          session.run_powershell_script(command) do |stdout, stderr|
-            stream_chunk(execute_options, stdout, stderr)
-          end
-        end
-        WinRMResult.new(command, execute_options, config, output)
-      end
-
-      def read_file(path)
-        result = execute("[Convert]::ToBase64String((Get-Content #{escape(path)} -Encoding byte -ReadCount 0))")
-        if result.exitstatus == 0
-          Base64.decode64(result.stdout)
-        else
-          nil
-        end
-      end
-
-      def write_file(path, content)
-        chunk_size = options[:chunk_size] || 1024
-        # TODO if we could marshal this data directly, we wouldn't have to base64 or do this godawful slow stuff :(
-        index = 0
-        execute("
-$ByteArray = [System.Convert]::FromBase64String(#{escape(Base64.encode64(content[index..index+chunk_size-1]))})
-$file = [System.IO.File]::Open(#{escape(path)}, 'Create', 'Write')
-$file.Write($ByteArray, 0, $ByteArray.Length)
-$file.Close
-").error!
-        index += chunk_size
-        while index < content.length
-          execute("
-$ByteArray = [System.Convert]::FromBase64String(#{escape(Base64.encode64(content[index..index+chunk_size-1]))})
-$file = [System.IO.File]::Open(#{escape(path)}, 'Append', 'Write')
-$file.Write($ByteArray, 0, $ByteArray.Length)
-$file.Close
-").error!
-          index += chunk_size
-        end
-      end
-
-      def disconnect
-        #
-      end
-
-      def escape(string)
-        "\"#{string.gsub("\"", "`\"")}\""
-      end
-
-      def available?
-        # If you can't pwd within 10 seconds, you can't pwd
-        execute('pwd', :timeout => 10)
-        true
-      rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET, ::WinRM::WinRMHTTPTransportError, ::WinRM::WinRMWebServiceError, ::WinRM::WinRMWSManFault
-        Chef::Log.debug("unavailable: network connection failed or broke: #{$!.inspect}")
-        disconnect
-        false
-      rescue ::WinRM::WinRMAuthorizationError
-        Chef::Log.debug("unavailable: winrm authentication error: #{$!.inspect} ")
-        disconnect
-        false
-      end
-
-      def make_url_available_to_remote(local_url)
-        uri = URI(local_url)
-        host = Socket.getaddrinfo(uri.host, uri.scheme, nil, :STREAM)[0][3]
-        if host == '127.0.0.1' || host == '::1'
-          raise 'Unable to converge locally via winrm. Local converge is currently only supported with SSH. You may only converge with winrm against a chef-server.'
-        end
-        local_url
-      end
-
-      protected
-
-      def session
-        @session ||= begin
-          require 'kconv' # Really, people? *sigh*
-          require 'winrm'
-          ::WinRM::WinRMWebService.new(endpoint, type, options)
-        end
-      end
-
-      class WinRMResult
-        def initialize(command, options, config, output)
-          @command = command
-          @options = options
-          @config = config
-          @exitstatus = output[:exitcode]
-          @stdout = ''
-          @stderr = ''
-          output[:data].each do |data|
-            @stdout << data[:stdout] if data[:stdout]
-            @stderr << data[:stderr] if data[:stderr]
-          end
-        end
-
-        attr_reader :stdout
-        attr_reader :stderr
-        attr_reader :exitstatus
-        attr_reader :command
-        attr_reader :options
-        attr_reader :config
-
-        def error!
-          if exitstatus != 0
-            msg = "Error: command '#{command}' exited with code #{exitstatus}.\n"
-            msg << "STDOUT: #{stdout}" if !options[:stream] && !options[:stream_stdout] && config[:log_level] != :debug
-            msg << "STDERR: #{stderr}" if !options[:stream] && !options[:stream_stderr] && config[:log_level] != :debug
-            raise msg
-          end
-        end
-      end
-    end
-  end
-end
+require "chef/provisioning/transport/winrm"

data/lib/chef_metal/version.rb

@@ -1,3 +1 @@
-module ChefMetal
-  VERSION = '0.14.2'
-end
+require "chef/provisioning/version"

metadata

@@ -1,192 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.14.2
+  version: '0.15'
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: chef
+  name: chef-provisioning
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: net-ssh
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: net-scp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: net-ssh-gateway
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-- !ruby/object:Gem::Dependency
-  name: inifile
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: cheffish
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: winrm
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.3
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A library for creating machines and infrastructures idempotently in Chef.
-email: jkeiser@opscode.com
-executables:
-- metal
+email: jkeiser@getchef.com
+executables: []
 extensions: []
-extra_rdoc_files:
-- README.md
-- CHANGELOG.md
-- LICENSE
+extra_rdoc_files: []
 files:
-- Rakefile
+- CHANGELOG.md
 - LICENSE
 - README.md
-- CHANGELOG.md
-- lib/chef/provider/machine.rb
-- lib/chef/provider/machine_batch.rb
-- lib/chef/provider/machine_execute.rb
-- lib/chef/provider/machine_file.rb
-- lib/chef/provider/machine_image.rb
-- lib/chef/resource/machine.rb
-- lib/chef/resource/machine_batch.rb
-- lib/chef/resource/machine_execute.rb
-- lib/chef/resource/machine_file.rb
-- lib/chef/resource/machine_image.rb
+- Rakefile
+- lib/chef_metal.rb
 - lib/chef_metal/action_handler.rb
 - lib/chef_metal/add_prefix_action_handler.rb
 - lib/chef_metal/chef_image_spec.rb
 - lib/chef_metal/chef_machine_spec.rb
 - lib/chef_metal/chef_provider_action_handler.rb
 - lib/chef_metal/chef_run_data.rb
+- lib/chef_metal/convergence_strategy.rb
 - lib/chef_metal/convergence_strategy/install_cached.rb
 - lib/chef_metal/convergence_strategy/install_msi.rb
 - lib/chef_metal/convergence_strategy/install_sh.rb
 - lib/chef_metal/convergence_strategy/no_converge.rb
 - lib/chef_metal/convergence_strategy/precreate_chef_objects.rb
-- lib/chef_metal/convergence_strategy.rb
 - lib/chef_metal/driver.rb
 - lib/chef_metal/image_spec.rb
+- lib/chef_metal/machine.rb
 - lib/chef_metal/machine/basic_machine.rb
 - lib/chef_metal/machine/unix_machine.rb
 - lib/chef_metal/machine/windows_machine.rb
-- lib/chef_metal/machine.rb
 - lib/chef_metal/machine_spec.rb
 - lib/chef_metal/recipe_dsl.rb
+- lib/chef_metal/transport.rb
 - lib/chef_metal/transport/ssh.rb
 - lib/chef_metal/transport/winrm.rb
-- lib/chef_metal/transport.rb
 - lib/chef_metal/version.rb
-- lib/chef_metal.rb
-- bin/metal
-homepage: http://wiki.opscode.com/display/chef
+homepage: http://github.com/opscode/chef-metal
 licenses: []
 metadata: {}
 post_install_message: 
@@ -195,18 +68,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A library for creating machines and infrastructures idempotently in Chef.
 test_files: []
+has_rdoc: 

data/bin/metal

@@ -1,275 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require 'chef_metal'
-require 'chef/rest'
-require 'chef/application'
-require 'chef/knife'
-require 'chef/run_context'
-require 'chef/server_api'
-require 'chef_metal/action_handler'
-require 'chef_metal/version'
-require 'chef_metal/chef_machine_spec'
-
-class ChefMetal::Application < Chef::Application
-
-  # Mimic self_pipe sleep from Unicorn to capture signals safely
-  SELF_PIPE = []
-
-  option :config_file,
-    :short => "-c CONFIG",
-    :long  => "--config CONFIG",
-    :description => "The configuration file to use"
-
-  option :log_level,
-    :short        => "-l LEVEL",
-    :long         => "--log_level LEVEL",
-    :description  => "Set the log level (debug, info, warn, error, fatal)",
-    :proc         => lambda { |l| l.to_sym }
-
-  option :log_location,
-    :short        => "-L LOGLOCATION",
-    :long         => "--logfile LOGLOCATION",
-    :description  => "Set the log file location, defaults to STDOUT - recommended for daemonizing",
-    :proc         => nil
-
-  option :node_name,
-    :short => "-N NODE_NAME",
-    :long => "--node-name NODE_NAME",
-    :description => "The node name for this client",
-    :proc => nil
-
-  option :chef_server_url,
-    :short => "-S CHEFSERVERURL",
-    :long => "--server CHEFSERVERURL",
-    :description => "The chef server URL",
-    :proc => nil
-
-  option :client_key,
-    :short        => "-k KEY_FILE",
-    :long         => "--client_key KEY_FILE",
-    :description  => "Set the client key file location",
-    :proc         => nil
-
-  option :local_mode,
-    :short        => "-z",
-    :long         => "--local-mode",
-    :description  => "Point chef-client at local repository",
-    :boolean      => true
-
-  option :chef_repo_path,
-    :long         => '--chef-repo-path=PATH',
-    :description  => "Path to Chef repository"
-
-  option :chef_zero_port,
-    :long         => "--chef-zero-port PORT",
-    :description  => "Port to start chef-zero on"
-
-  option :read_only,
-    :long         => "--[no-]read-only",
-    :description  => "Promise that execution will not modify the machine (helps with Docker in particular)"
-
-  option :stream,
-    :long         => "--[no-]stream",
-    :default      => true,
-    :boolean      => true,
-    :description  => "Whether to stream output from the machine (default: true)"
-
-  option :timeout,
-    :long         => "--timeout=TIMEOUT",
-    :default      => 15*60,
-    :description  => "Time to wait for program to execute, or 0 for no timeout (default: 15 minutes)"
-
-  def reconfigure
-    super
-
-    Chef::Config.chef_server_url = config[:chef_server_url] if config.has_key? :chef_server_url
-
-    Chef::Config.chef_repo_path = config[:chef_repo_path] if config.has_key? :chef_repo_path
-
-    Chef::Config.local_mode = config[:local_mode] if config.has_key?(:local_mode)
-    if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
-      Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
-    end
-    Chef::Config.chef_zero.port = config[:chef_zero_port] if config[:chef_zero_port]
-  end
-
-  def setup_application
-  end
-
-  def load_config_file
-    if !config.has_key?(:config_file)
-      require 'chef/knife'
-      config[:config_file] = Chef::Knife.locate_config_file
-    end
-    super
-  end
-
-  def run_application
-    exit_code = 0
-
-    Cheffish.honor_local_mode do
-      command = cli_arguments.shift
-      case command
-      when 'execute'
-        connect_to_machines(cli_arguments.shift) do |machine|
-          result = machine.execute(action_handler, cli_arguments.join(' '), :read_only => config[:read_only], :stream => config[:stream], :timeout => config[:timeout].to_f)
-          puts result.stdout if result.stdout != '' && !config[:stream] && Chef::Config.log_level != :debug
-          STDERR.puts result.stderr if result.stderr != '' && !config[:stream] && Chef::Config.log_level != :debug
-          exit_code = result.exitstatus if result.exitstatus != 0
-        end
-      when 'destroy'
-        each_current_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.destroy_machines(action_handler, specs_and_options, parallelizer)
-        end
-      when 'allocate'
-        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
-        end
-      when 'ready'
-        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
-          driver.ready_machines(action_handler, specs_and_options, parallelizer)
-        end
-      when 'setup'
-        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
-          driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
-            machine.setup_convergence(action_handler)
-          end
-        end
-      when 'converge'
-        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
-          driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
-            # TODO upload files?  Maybe they should be in machine_options?
-            machine.setup_convergence(action_handler)
-            machine.converge(action_handler)
-          end
-        end
-      when 'reconverge'
-        connect_to_machines(cli_arguments.shift) do |machine|
-          machine.converge(action_handler)
-        end
-      when 'stop'
-        each_current_machine(cli_arguments.shift) do |driver, specs_and_options|
-          driver.stop_machines(action_handler, specs_and_options, parallelizer)
-        end
-      when 'cat'
-        connect_to_machines(cli_arguments.shift) do |machine|
-          cli_arguments.each do |remote_path|
-            puts machine.read_file(remote_path)
-          end
-        end
-      when 'cp'
-        machines = {}
-        to = cli_arguments.pop
-        if to =~ /^([^\/:]+):(.+)$/
-          to_server = $1
-          machines[to_server] ||= ChefMetal.connect_to_machine(to_server)
-          to_path = $2
-          to_is_directory = machines[to_server].is_directory?(to_path)
-        else
-          to_server = nil
-          to_path = File.absolute_path(to)
-        end
-
-        cli_arguments.each do |from|
-          if from =~ /^([^\/:]+):(.+)$/
-            from_server = $1
-            from_path = $2
-            if to_server
-              raise "Cannot copy from one server to another, or intraserver (from=#{from}, to=#{to})"
-            end
-
-            machines[from_server] ||= connect_to_machine(from_server)
-            if File.directory?(to_path)
-              machines[from_server].download_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
-            else
-              machines[from_server].download_file(action_handler, from_path, to_path)
-            end
-          else
-            from_server = nil
-            from_path = File.absolute_path(from)
-            if !to_server
-              raise "Cannot copy two local files.  One of the arguments must be MACHINE:PATH.  (from=#{from}, to=#{to})"
-            end
-
-            if to_is_directory
-              machines[to_server].upload_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
-            else
-              machines[to_server].upload_file(action_handler, from_path, to_path)
-            end
-          end
-        end
-      else
-        Chef::Log.error("Command '#{command}' unrecognized")
-      end
-    end
-
-    exit(exit_code) if exit_code != 0
-  end
-
-  private
-
-  def rest
-    @rest ||= Chef::ServerAPI.new()
-  end
-
-  def machine_specs(*specs)
-    names = specs.collect_concat { |spec| spec.split(',') }.uniq
-    parallelizer.parallelize(names) { |name| ChefMetal::ChefMachineSpec.get(name) }.to_a
-  end
-
-  def each_new_machine(spec)
-    driver = ChefMetal.default_driver
-    specs_and_options = {}
-    machine_specs(spec).each do |machine_spec|
-      specs_and_options[machine_spec] = driver.config[:machine_options]
-    end
-    [ [ driver,  specs_and_options ] ]
-  end
-
-  def each_current_machine(spec)
-    grouped = machine_specs(spec).group_by { |machine_spec| machine_spec.driver_url }
-    parallelizer.parallelize(grouped) do |driver_url, machine_specs|
-      if driver_url
-        driver = ChefMetal.driver_for_url(driver_url)
-        specs_and_options = {}
-        machine_specs(spec).each do |machine_spec|
-          specs_and_options[machine_spec] = driver.config[:machine_options]
-        end
-        yield driver, specs_and_options
-      end
-    end.to_a
-  end
-
-  def connect_to_machines(spec)
-    machine_specs(spec).each do |machine_spec|
-      yield ChefMetal.connect_to_machine(machine_spec)
-    end
-  end
-
-  def parallelizer
-    Chef::ChefFS::Parallelizer
-  end
-
-  def action_handler
-    @action_handler ||= ActionHandler.new
-  end
-
-  class ActionHandler < ChefMetal::ActionHandler
-    def recipe_context
-      # TODO: somehow remove this code; should context really always be needed?
-      node = Chef::Node.new
-      node.name 'nothing'
-      node.automatic[:platform] = 'metal'
-      node.automatic[:platform_version] = ChefMetal::VERSION
-      Chef::RunContext.new(node, {},
-        Chef::EventDispatch::Dispatcher.new(Chef::Formatters::Doc.new(STDOUT,STDERR)))
-    end
-  end
-end
-
-ChefMetal::Application.new.run