chef-provisioning 0.15

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

@@ -0,0 +1,151 @@
+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))
+          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
+end

data/lib/chef/provisioning/version.rb

@@ -0,0 +1,5 @@
+class Chef
+module Provisioning
+  VERSION = '0.15'
+end
+end

data/lib/chef/resource/chef_data_bag_resource.rb

@@ -0,0 +1,148 @@
+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
+    # A list of attributes to be persisted into the databag.
+    attr_reader :stored_attributes
+  end
+
+  def initialize(name, run_context=nil)
+    super
+    Chef::Log.debug("Re-hydrating #{name} from #{self.class.databag_name}...")
+    self.hydrate
+  end
+
+  # @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)
+    @stored_attributes ||= []
+    @stored_attributes << attr_name
+    self.attribute attr_name
+  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
+

data/lib/chef/resource/load_balancer.rb

@@ -0,0 +1,57 @@
+require 'chef/resource/lwrp_base'
+require 'cheffish'
+require 'chef_metal'
+require 'cheffish/merged_config'
+
+class Chef
+  class Resource
+    class LoadBalancer < Chef::Resource::LWRPBase
+
+      self.resource_name = 'load_balancer'
+
+      def initialize(*args)
+        super
+        @chef_environment = run_context.cheffish.current_environment
+        @chef_server = run_context.cheffish.current_chef_server
+        @driver = run_context.chef_metal.current_driver
+        @load_balancer_options = run_context.chef_metal.current_load_balancer_options
+      end
+
+      actions :create, :destroy
+      default_action :create
+
+      # Driver attributes
+      attribute :driver
+      attribute :load_balancer_options
+      attribute :name, :kind_of => String, :name_attribute => true
+      attribute :machines
+
+      def add_load_balancer_options(options)
+        @load_balancer_options = Cheffish::MergedConfig.new(options, @load_balancer_options)
+      end
+
+
+      # This is here because metal users will probably want to do things like:
+      # machine "foo"
+      #   action :destroy
+      # end
+      #
+      # with_load_balancer_options :bootstrap_options => {...}
+      # machine "foo"
+      #   converge true
+      # end
+      #
+      # Without this, the first resource's machine options will obliterate the second
+      # resource's machine options, and then unexpected (and undesired) things happen.
+      def load_prior_resource
+        Chef::Log.debug "Overloading #{self.resource_name} load_prior_resource with NOOP"
+      end
+
+      # chef client version and omnibus
+      # chef-zero boot method?
+      # chef-client -z boot method?
+      # pushy boot method?
+    end
+  end
+end
+

data/lib/chef/resource/machine.rb

@@ -0,0 +1,124 @@
+require 'chef/resource/lwrp_base'
+require 'cheffish'
+require 'chef/provisioning'
+require 'cheffish/merged_config'
+
+class Chef
+class Resource
+class Machine < Chef::Resource::LWRPBase
+
+  self.resource_name = 'machine'
+
+  def initialize(*args)
+    super
+    @chef_environment = run_context.cheffish.current_environment
+    @chef_server = run_context.cheffish.current_chef_server
+    @driver = run_context.chef_provisioning.current_driver
+    @machine_options = run_context.chef_provisioning.current_machine_options
+  end
+
+  actions :allocate, :ready, :setup, :converge, :converge_only, :destroy, :stop
+  default_action :converge
+
+  # Driver attributes
+  attribute :driver
+
+  # Machine options
+  attribute :machine_options
+
+  # Node attributes
+  Cheffish.node_attributes(self)
+
+  # Client keys
+  # Options to generate private key (size, type, etc.) when the server doesn't have it
+  attribute :private_key_options, :kind_of => Hash
+  attribute :allow_overwrite_keys, :kind_of => [TrueClass, FalseClass]
+
+  # Optionally pull the public key out to a file
+  attribute :public_key_path, :kind_of => String
+  attribute :public_key_format, :kind_of => String
+
+  # If you really want to force the private key to be a certain key, pass these
+  attribute :source_key
+  attribute :source_key_path, :kind_of => String
+  attribute :source_key_pass_phrase
+
+  # Client attributes
+  attribute :admin, :kind_of => [TrueClass, FalseClass]
+  attribute :validator, :kind_of => [TrueClass, FalseClass]
+
+  # Client Ohai hints, allows machine to enable hints
+  # e.g. ohai_hint 'ec2' => { 'a' => 'b' } creates file ec2.json with json contents { 'a': 'b' }
+  attribute :ohai_hints, :kind_of => Hash
+
+  # Allows you to turn convergence off in the :create action by writing "converge false"
+  # or force it with "true"
+  attribute :converge, :kind_of => [TrueClass, FalseClass]
+
+  # A list of files to upload, in the format REMOTE_PATH => LOCAL_PATH|HASH.
+  # == Examples
+  # files '/remote/path.txt' => '/local/path.txt'
+  # files '/remote/path.txt' => { :local_path => '/local/path.txt' }
+  # files '/remote/path.txt' => { :content => 'woo' }
+  attribute :files, :kind_of => Hash
+
+  # The named machine_image to start from.  Specify the name of a machine_image
+  # object and the default machine_options will be set to use that image.
+  # == Examples
+  # from_image 'company_base_image'
+  attribute :from_image, :kind_of => String
+
+  # A single file to upload, in the format REMOTE_PATH, LOCAL_PATH|HASH.
+  # This directive may be passed multiple times, and multiple files will be uploaded.
+  # == Examples
+  # file '/remote/path.txt', '/local/path.txt'
+  # file '/remote/path.txt', { :local_path => '/local/path.txt' }
+  # file '/remote/path.txt', { :content => 'woo' }
+  def file(remote_path, local = nil)
+    @files ||= {}
+    if remote_path.is_a?(Hash)
+      if local
+        raise "file(Hash, something) does not make sense.  Either pass a hash, or pass a pair, please."
+      end
+      remote_path.each_pair do |remote, local|
+        @files[remote] = local
+      end
+    elsif remote_path.is_a?(String)
+      if !local
+        raise "Must pass both a remote path and a local path to file directive"
+      end
+      @files[remote_path] = local
+    else
+      raise "file remote_path must be a String, but is a #{remote_path.class}"
+    end
+  end
+
+  def add_machine_options(options)
+    @machine_options = Cheffish::MergedConfig.new(options, @machine_options)
+  end
+
+
+  # This is here because provisioning users will probably want to do things like:
+  # machine "foo"
+  #   action :destroy
+  # end
+  #
+  # @example
+  #   with_machine_options :bootstrap_options => { ... }
+  #   machine "foo"
+  #     converge true
+  #   end
+  #
+  # Without this, the first resource's machine options will obliterate the second
+  # resource's machine options, and then unexpected (and undesired) things happen.
+  def load_prior_resource
+    Chef::Log.debug "Overloading #{self.resource_name} load_prior_resource with NOOP"
+  end
+
+  # chef client version and omnibus
+  # chef-zero boot method?
+  # chef-client -z boot method?
+  # pushy boot method?
+end
+end
+end