chef-provisioning 2.0.0 → 2.0.1

data/lib/chef/provisioning/transport/winrm.rb

@@ -1,156 +1,144 @@
-require 'chef/provisioning/transport'
-require 'base64'
-require 'timeout'
-
-class Chef
-module Provisioning
-  class Transport
-    # Transport to handle the WinRM connection protocol.
-    class WinRM < Chef::Provisioning::Transport
-      #
-      # Create a new WinRM transport.
-      #
-      # == Arguments
-      # - endpoint: the WinRM endpoint, e.g. http://145.14.51.45:5985/wsman.
-      # - type: the connection type, e.g. :plaintext.
-      # - options: options hash, including both WinRM options and transport options.
-      #   For transport options, see the Transport.options definition.  WinRM
-      #   options include :user, :pass, :disable_sspi => true, among others.
-      # - global_config: an options hash that looks suspiciously similar to
-      #   Chef::Config, containing at least the key :log_level.
-      #
-      # The actual connection is made as ::WinRM::WinRMWebService.new(endpoint, type, options)
-      #
-      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))
-          command_executor = ::WinRM::CommandExecutor.new(session)
-          block = Proc.new { |stdout, stderr| stream_chunk(execute_options, stdout, stderr) }
-          if execute_options[:raw]
-            command_executor.run_cmd(command, &block)
-          else
-            command_executor.run_powershell_script(command, &block)
-          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)
-        execute("New-Item -Type Directory -Force -Path #{escape(::File.dirname(path))}").error!
-        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 ::WinRM::WinRMAuthorizationError
-        Chef::Log.debug("unavailable: winrm authentication error: #{$!.inspect} ")
-        disconnect
-        false
-      rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET, ::WinRM::WinRMError
-        Chef::Log.debug("unavailable: network connection failed or broke: #{$!.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
-end
+require 'chef/provisioning/transport'
+require 'base64'
+require 'timeout'
+
+class Chef
+module Provisioning
+  class Transport
+    # Transport to handle the WinRM connection protocol.
+    class WinRM < Chef::Provisioning::Transport
+      #
+      # Create a new WinRM transport.
+      #
+      # == Arguments
+      # - endpoint: the WinRM endpoint, e.g. http://145.14.51.45:5985/wsman.
+      # - type: the connection type, e.g. :plaintext.
+      # - options: options hash, including both WinRM options and transport options.
+      #   For transport options, see the Transport.options definition.  WinRM
+      #   options include :user, :pass, :disable_sspi => true, among others.
+      # - global_config: an options hash that looks suspiciously similar to
+      #   Chef::Config, containing at least the key :log_level.
+      #
+      # The actual connection is made as ::WinRM::WinRMWebService.new(endpoint, type, options)
+      #
+      def initialize(endpoint, type, options, global_config)
+        @options = options
+        @options[:endpoint] = endpoint
+        @options[:transport] = type
+
+        # WinRM v2 switched from :pass to :password
+        # we accept either to avoid having to update every driver
+        @options[:password] = @options[:password] || @options[:pass]
+        
+        @config = global_config
+      end
+
+      attr_reader :options
+      attr_reader :config
+
+      def execute(command, execute_options = {})
+        output = with_execute_timeout(execute_options) do
+          block = Proc.new { |stdout, stderr| stream_chunk(execute_options, stdout, stderr) }
+          session.run(command, &block)
+        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)
+        file = Tempfile.new('provisioning-upload')
+        begin
+           file.write(content)
+           file.close
+           file_transporter.upload(file.path, path)
+        ensure
+           file.unlink
+        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 ::WinRM::WinRMAuthorizationError
+        Chef::Log.debug("unavailable: winrm authentication error: #{$!.inspect} ")
+        disconnect
+        false
+      rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET, ::WinRM::WinRMError
+        Chef::Log.debug("unavailable: network connection failed or broke: #{$!.inspect}")
+        disconnect
+        false
+      end
+
+      def make_url_available_to_remote(local_url)
+        uri = URI(local_url)
+        uri.scheme = 'http' if uri.scheme == 'chefzero' && uri.host == 'localhost'
+        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 'winrm'
+          ::WinRM::Connection.new(options).shell(:powershell)
+        end
+      end
+
+      def file_transporter
+        @file_transporter ||= begin
+          require 'winrm-fs'
+          ::WinRM::FS::Core::FileTransporter.new(session)
+        end
+      end
+
+      class WinRMResult
+        def initialize(command, options, config, output)
+          @command = command
+          @options = options
+          @config = config
+          @exitstatus = output.exitcode
+          @stdout = output.stdout
+          @stderr = output.stderr
+        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
+end

data/lib/chef/provisioning/version.rb

@@ -1,5 +1,5 @@
-class Chef
-module Provisioning
-  VERSION = '2.0.0'
-end
-end
+class Chef
+module Provisioning
+  VERSION = '2.0.1'
+end
+end

data/lib/chef/resource/chef_data_bag_resource.rb

@@ -1,146 +1,146 @@
-require 'chef/resource/lwrp_base'
-require 'cheffish'
-
-# A resource that is backed by a data bag in a Chef server somewhere
-class Chef::Resource::ChefDataBagResource < Chef::Resource::LWRPBase
-
-  # The key to store this thing under (/data/bag/<<name>>).
-  attr_reader :name
-
-  class << self
-    # The name of the databag to store the item in.
-    attr_reader :databag_name
-  end
-
-  def initialize(name, run_context=nil)
-    super
-    Chef::Log.debug("Re-hydrating #{name} from #{self.class.databag_name}...")
-    self.hydrate
-  end
-
-  # A list of attributes to be persisted into the databag.
-  # @return [Array] List of attributes that are stored in the databag
-  def self.stored_attributes
-    @stored_attributes || []
-  end
-
-  # Set databag name
-  # @return [Void]
-  def self.databag_name= name
-    Chef::Log.debug("Setting databag name to #{name}")
-    @databag_name = name
-  end
-
-  # Mark an attribute as stored by adding it to the internal tracking list {stored_attributes}
-  # and then delegating to {Chef::Resource::LWRPBase#attribute}
-  # @param attr_name [Symbol] Name of the attribute as a symbol
-  # @return [Void]
-  def self.stored_attribute(attr_name, *args)
-    @stored_attributes ||= []
-    @stored_attributes << attr_name
-    self.attribute attr_name, *args
-  end
-
-  # Load persisted data from the server's databag. If the databag does not exist on the
-  # server, returns nil.
-  #
-  # @param chef_server [Hash] A hash representing which Chef server to talk to
-  # @option chef_server [String] :chef_server_url URL to the Chef server
-  # @option chef_server [Hash] :options Options for when talking to the Chef server
-  # @option options [String] :client_name The node name making the call
-  # @option options [String] :signing_key_filename Path to the signing key
-  # @return [Object] an instance of this class re-hydrated from the data hash stored in the
-  # databag.
-  def hydrate(chef_server = Cheffish.default_chef_server)
-    chef_api = Cheffish.chef_server_api(chef_server)
-    begin
-      data = chef_api.get("/data/#{self.class.databag_name}/#{name}")
-      load_from_hash(data)
-      Chef::Log.debug("Rehydrating resource from #{self.class.databag_name}/#{name}: #{data}")
-    rescue Net::HTTPServerException => e
-      if e.response.code == '404'
-        nil
-      else
-        raise
-      end
-    end
-  end
-
-  # Load instance variable data from a hash. For each key,value pair, set @<key> to value
-  # @param hash [Hash] Hash containing the instance variable data
-  # @return [Object] self after having been populated with data.
-  def load_from_hash hash
-    hash.each do |k,v|
-      self.instance_variable_set("@#{k}", v)
-    end
-    self
-  end
-
-  # Convert the values in {stored_attributes} to a hash for storing in a databag
-  # @return [Hash] a hash of (k,v) pairs where k is each record in {stored_attributes}
-  def storage_hash
-    ignored = []
-
-    hash = {}
-    (self.class.stored_attributes - ignored).each do |attr_name|
-      varname = "@#{attr_name.to_s.gsub('@', '')}"
-      key = varname.gsub('@', '')
-      hash[key] = self.instance_variable_get varname
-    end
-
-    hash
-  end
-
-
-  # Save this entity to the server.  If you have significant information that
-  # could be lost, you should do this as quickly as possible.
-  # @return [Void]
-  def save
-
-    create_databag_if_needed self.class.databag_name
-
-    # Clone for inline_resource
-    _databag_name = self.class.databag_name
-    _hash = self.storage_hash
-    _name = self.name
-
-    Cheffish.inline_resource(self, @action) do
-      chef_data_bag_item _name do
-        data_bag _databag_name
-        raw_data _hash
-        action :create
-      end
-    end
-  end
-
-  # Delete this entity from the server
-  # @return [Void]
-  def delete
-    # Clone for inline_resource
-    _name = self.name
-    _databag_name = self.class.databag_name
-
-    Cheffish.inline_resource(self, @action) do
-      chef_data_bag_item _name do
-        data_bag _databag_name
-        action :delete
-      end
-    end
-  end
-
-  def new_resource
-    self
-  end
-
-  private
-  # Create the databag with Cheffish if required
-  # @return [Void]
-  def create_databag_if_needed databag_name
-    _databag_name = databag_name
-    Cheffish.inline_resource(self, @action) do
-      chef_data_bag _databag_name do
-        action :create
-      end
-    end
-  end
-end
+require 'chef/resource/lwrp_base'
+require 'cheffish'
+
+# A resource that is backed by a data bag in a Chef server somewhere
+class Chef::Resource::ChefDataBagResource < Chef::Resource::LWRPBase
+
+  # The key to store this thing under (/data/bag/<<name>>).
+  attr_reader :name
+
+  class << self
+    # The name of the databag to store the item in.
+    attr_reader :databag_name
+  end
+
+  def initialize(name, run_context=nil)
+    super
+    Chef::Log.debug("Re-hydrating #{name} from #{self.class.databag_name}...")
+    self.hydrate
+  end
+
+  # A list of attributes to be persisted into the databag.
+  # @return [Array] List of attributes that are stored in the databag
+  def self.stored_attributes
+    @stored_attributes || []
+  end
+
+  # Set databag name
+  # @return [Void]
+  def self.databag_name= name
+    Chef::Log.debug("Setting databag name to #{name}")
+    @databag_name = name
+  end
+
+  # Mark an attribute as stored by adding it to the internal tracking list {stored_attributes}
+  # and then delegating to {Chef::Resource::LWRPBase#attribute}
+  # @param attr_name [Symbol] Name of the attribute as a symbol
+  # @return [Void]
+  def self.stored_attribute(attr_name, *args)
+    @stored_attributes ||= []
+    @stored_attributes << attr_name
+    self.attribute attr_name, *args
+  end
+
+  # Load persisted data from the server's databag. If the databag does not exist on the
+  # server, returns nil.
+  #
+  # @param chef_server [Hash] A hash representing which Chef server to talk to
+  # @option chef_server [String] :chef_server_url URL to the Chef server
+  # @option chef_server [Hash] :options Options for when talking to the Chef server
+  # @option options [String] :client_name The node name making the call
+  # @option options [String] :signing_key_filename Path to the signing key
+  # @return [Object] an instance of this class re-hydrated from the data hash stored in the
+  # databag.
+  def hydrate(chef_server = Cheffish.default_chef_server)
+    chef_api = Cheffish.chef_server_api(chef_server)
+    begin
+      data = chef_api.get("/data/#{self.class.databag_name}/#{name}")
+      load_from_hash(data)
+      Chef::Log.debug("Rehydrating resource from #{self.class.databag_name}/#{name}: #{data}")
+    rescue Net::HTTPServerException => e
+      if e.response.code == '404'
+        nil
+      else
+        raise
+      end
+    end
+  end
+
+  # Load instance variable data from a hash. For each key,value pair, set @<key> to value
+  # @param hash [Hash] Hash containing the instance variable data
+  # @return [Object] self after having been populated with data.
+  def load_from_hash hash
+    hash.each do |k,v|
+      self.instance_variable_set("@#{k}", v)
+    end
+    self
+  end
+
+  # Convert the values in {stored_attributes} to a hash for storing in a databag
+  # @return [Hash] a hash of (k,v) pairs where k is each record in {stored_attributes}
+  def storage_hash
+    ignored = []
+
+    hash = {}
+    (self.class.stored_attributes - ignored).each do |attr_name|
+      varname = "@#{attr_name.to_s.gsub('@', '')}"
+      key = varname.gsub('@', '')
+      hash[key] = self.instance_variable_get varname
+    end
+
+    hash
+  end
+
+
+  # Save this entity to the server.  If you have significant information that
+  # could be lost, you should do this as quickly as possible.
+  # @return [Void]
+  def save
+
+    create_databag_if_needed self.class.databag_name
+
+    # Clone for inline_resource
+    _databag_name = self.class.databag_name
+    _hash = self.storage_hash
+    _name = self.name
+
+    Cheffish.inline_resource(self, @action) do
+      chef_data_bag_item _name do
+        data_bag _databag_name
+        raw_data _hash
+        action :create
+      end
+    end
+  end
+
+  # Delete this entity from the server
+  # @return [Void]
+  def delete
+    # Clone for inline_resource
+    _name = self.name
+    _databag_name = self.class.databag_name
+
+    Cheffish.inline_resource(self, @action) do
+      chef_data_bag_item _name do
+        data_bag _databag_name
+        action :delete
+      end
+    end
+  end
+
+  def new_resource
+    self
+  end
+
+  private
+  # Create the databag with Cheffish if required
+  # @return [Void]
+  def create_databag_if_needed databag_name
+    _databag_name = databag_name
+    Cheffish.inline_resource(self, @action) do
+      chef_data_bag _databag_name do
+        action :create
+      end
+    end
+  end
+end