chef-metal-ssh 0.0.4 → 0.1.2

data/README.md

@@ -20,20 +20,70 @@ Or install it yourself as:
 
 ## Usage
 
+* valid machine options: one of the two is required, ip address is boss if both given
+
+        :ip_address,
+        :fqdn - this can be a shortname too as long as it resolves
+
+
+* valid ssh options
+
+        :auth_methods, 
+        :bind_address, 
+        :compression, 
+        :compression_level, 
+        :config,
+        :encryption, 
+        :forward_agent, 
+        :hmac, 
+        :host_key,
+        :keepalive, 
+        :keepalive_interval, 
+        :kex, 
+        :keys, 
+        :key_data,
+        :languages, 
+        :logger, 
+        :paranoid, 
+        :password, 
+        :port, 
+        :proxy,
+        :rekey_blocks_limit,
+        :rekey_limit, 
+        :rekey_packet_limit, 
+        :timeout, 
+        :verbose,
+        :global_known_hosts_file, 
+        :user_known_hosts_file, 
+        :host_key_alias,
+        :host_name, 
+        :user, 
+        :properties, 
+        :passphrase, 
+        :keys_only, 
+        :max_pkt_size,
+        :max_win_size, :send_env, 
+        :use_agent
+
+* machine resource example:
+
+		require 'chef_metal_ssh'
+		
+		with_ssh_cluster("~/metal_ssh")
+
 		machine "one" do
-		  action :create
-		  converge true
-		  provisioner ChefMetalSsh::SshProvisioner.new
-		  provisioner_options 'target_ip' => '192.168.33.21',
-		                      'ssh_user' => 'vagrant',
-		                      'ssh_options' => {
-		                        'password' => 'vagrant'
-		                      }
+		  action [:ready, :converge]
+		  machine_options 'ip_address' => '192.168.33.21',
+		                  'ssh_options' => {
+		                    'user' => 'vagrant',
+		                    'password' => 'vagrant'
+		                  }
 		  recipe 'ssh_test::remote1'
 		  notifies :create, 'machine[two]'
 		  notifies :run, 'execute[run_touch1]'
 		end
 
+
 To test it out, clone the repo:
 
 `git clone https://github.com/double-z/chef-metal-ssh.git`

data/lib/chef/provider/ssh_cluster.rb

@@ -0,0 +1,31 @@
+require 'chef/provider/lwrp_base'
+require 'cheffish'
+
+class Chef::Provider::SshCluster < Chef::Provider::LWRPBase
+
+  use_inline_resources
+
+  def whyrun_supported?
+    true
+  end
+
+  action :create do
+    the_base_path = new_resource.path
+    Cheffish.inline_resource(self, :create) do
+      directory the_base_path
+    end
+  end
+
+  action :delete do
+    the_base_path = new_resource.path
+    Cheffish.inline_resource(self, :delete) do
+      directory the_base_path do
+        action :delete
+      end
+    end
+  end
+
+  def load_current_resource
+  end
+
+end

data/lib/chef/provider/ssh_target.rb

@@ -0,0 +1,78 @@
+# require 'json'
+# require 'chef/provider/lwrp_base'
+# require 'chef_metal/provider_action_handler'
+
+# class Chef::Provider::SshTarget < Chef::Provider::LWRPBase
+
+#   include ChefMetal::ProviderActionHandler
+
+#   use_inline_resources
+
+#   def whyrun_supported?
+#     true
+#   end
+
+#   action :register do
+
+#     ip_address = new_resource.name
+#     target_registration_file_json = target_registration_file_to_json(new_resource)
+#     base_ssh_cluster_path = new_resource.ssh_cluster_path
+#     puts
+#     puts '::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json")'
+#     puts ::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json")
+
+#     unless ::File.exists?(::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json"))
+#       ChefMetal.inline_resource(self) do
+#         file ::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json") do
+#           Chef::Log.info(::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json"))
+#           content target_registration_file_json
+#           not_if { ::File.exists?(::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json")) }
+#         end
+#       end
+#     end
+
+#   end
+
+#   action :update do
+
+#     ip_address = new_resource.name
+#     target_registration_file_json = target_registration_file_to_json(new_resource)
+#     base_ssh_cluster_path = new_resource.ssh_cluster_path
+
+#     ChefMetal.inline_resource(self) do
+#       file ::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json") do
+#         content target_registration_file_json
+#         not_if { ::File.exists?(::File.join(Chef::Resource::SshCluster.path, "#{ip_address}.json")) }
+#       end
+#     end
+#   end
+
+#   def load_current_resource
+#   end
+
+# end
+
+# def target_registration_file_to_json(new_resource)
+
+#   # Determine contents of registration file
+#   target_registration_file_content = {}
+#   target_registration_file_content = target_registration_file_content.merge!({ 'available' => new_resource.available })
+#   target_registration_file_content = target_registration_file_content.merge!({ 'ip_address' => new_resource.name })
+#   target_registration_file_content = target_registration_file_content.merge!({ 'machine_types' => new_resource.machine_types })
+#   target_registration_file_content = target_registration_file_content.merge!({ 'mac_address' => new_resource.mac_address }) #if new_resource.mac_address
+#   target_registration_file_content = target_registration_file_content.merge!({ 'hostname' => new_resource.hostname }) #if new_resource.hostname
+#   target_registration_file_content = target_registration_file_content.merge!({ 'password' => new_resource.password }) #if new_resource.hostname
+#   target_registration_file_content = target_registration_file_content.merge!({ 'key' => new_resource.key }) #if new_resource.hostname
+#   target_registration_file_content = target_registration_file_content.merge!({ 'subnet' => new_resource.subnet }) #if new_resource.subnet
+#   target_registration_file_content = target_registration_file_content.merge!({ 'domain' => new_resource.domain }) #if new_resource.domain
+#   target_registration_file_content = target_registration_file_content.merge!({ 'fqdn' => new_resource.fqdn }) #if new_resource.fqdn
+#   target_registration_file_content = target_registration_file_content.merge!({ 'memory' => new_resource.memory }) #if new_resource.memory
+#   target_registration_file_content = target_registration_file_content.merge!({ 'cpu_count' => new_resource.cpu_count }) #if new_resource.cpu_count
+#   target_registration_file_content = target_registration_file_content.merge!({ 'cpu_type' => new_resource.cpu_type }) #if new_resource.cpu_type
+#   target_registration_file_content = target_registration_file_content.merge!({ 'arch' => new_resource.arch }) #if new_resource.arch
+
+#   target_registration_file_json = JSON.parse(target_registration_file_content.to_json)
+#   target_registration_file_json_content = JSON.pretty_generate(target_registration_file_json)
+#   target_registration_file_json_content
+
+# end

data/lib/chef/resource/ssh_cluster.rb

@@ -0,0 +1,21 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal_ssh'
+
+class Chef::Resource::SshCluster < Chef::Resource::LWRPBase
+ self.resource_name = 'ssh_cluster'
+
+ actions :create, :delete, :nothing
+ default_action :create
+
+ attribute :path, :kind_of => String, :name_attribute => true
+
+  def after_created
+    super
+    run_context.chef_metal.with_driver "ssh:#{path}"
+  end
+
+  # We are not interested in Chef's cloning behavior here.
+  def load_prior_resource
+    Chef::Log.debug("Overloading #{resource_name}.load_prior_resource with NOOP")
+  end
+end

data/lib/chef/resource/ssh_target.rb

@@ -0,0 +1,71 @@
+# require 'chef/resource/lwrp_base'
+
+# class Chef::Resource::SshTarget < Chef::Resource::LWRPBase
+
+#   self.resource_name = 'ssh_target'
+  
+#   actions :register, :update
+
+#   default_action :register
+
+#   attribute :ip_address,
+#   	:kind_of => [String],
+#   	:name => true
+
+#   # TODO, get path from cluster resource
+#   attribute :ssh_cluster_path,
+#   	:kind_of => [String]
+
+#   attribute :mac_address,
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :hostname,
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :password,
+#     :kind_of => [String],
+#     :default => ""
+ 
+#   attribute :key,
+#     :kind_of => [String],
+#     :default => ""
+ 
+#   attribute :subnet,
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :domain,
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :fqdn,
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :available, 
+#   	:kind_of => [String],
+#   	:default => "true"
+
+#   attribute :machine_types, 
+#   	:kind_of => [Array],
+#   	:default => Array.new
+
+#   attribute :memory, 
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :cpu_count, 
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :cpu_type, 
+#   	:kind_of => [String],
+#   	:default => ""
+
+#   attribute :arch, 
+#   	:kind_of => [String],
+#   	:default => ""
+
+# end

data/lib/chef_metal/driver_init/ssh.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_ssh/ssh_driver'
+
+ChefMetal.register_driver_class('ssh', ChefMetalSsh::SshDriver)

data/lib/chef_metal_ssh.rb

@@ -1,2 +1,17 @@
 require 'chef_metal'
-require 'chef_metal_ssh/ssh_provisioner'
+require 'chef/resource/ssh_cluster'
+require 'chef/provider/ssh_cluster'
+require 'chef/resource/ssh_target'
+require 'chef/provider/ssh_target'
+# require 'chef_metal_ssh/machine_registry'
+require 'chef_metal_ssh/ssh_driver'
+
+class Chef
+	module DSL
+		module Recipe
+			def with_ssh_cluster(cluster_path, &block)
+				with_driver("ssh:#{cluster_path}", &block)
+			end
+		end
+	end
+end

data/lib/chef_metal_ssh/machine_registry.rb

@@ -0,0 +1,230 @@
+# require 'chef_metal_ssh'
+
+module ChefMetalSsh
+  module MachineRegistry
+
+    def validate_machine_options(node)
+
+      allowed_new_machine_keys = %w{
+        ssh_cluster_path
+        machine_types
+        mac_address
+        ip_address
+        subnet
+        hostname
+        domain
+        fqdn
+        memory
+        cpu_count
+        cpu_type
+        arch
+      }
+
+      # Validate Machine Options
+      new_machine.each { |k,v| raise 'Invalid Machine Option' unless allowed_new_machine_keys.include?(k) }
+
+      if new_machine['cpu_type'] && ! new_machine['cpu_type'].empty?
+        raise "Bad Cpu Type" unless ( new_machine['cpu_type'] == 'intel' || new_machine['cpu_type'] == 'amd' )
+      end
+
+      if new_machine['arch']
+        raise "No Such Arch. Either i386 or x86_64" unless ( new_machine['arch'] == 'i386' || new_machine['arch'] == 'x86_64' )
+      end
+
+    end
+
+    def registered_machine_is_available?(v)
+      case v
+      when "true"
+        true
+      when "false"
+        false
+      when nil
+        true
+      else
+        raise "Available Key is not true or false string"
+      end
+    end
+
+    def delete_provider_registration_file(action_handler, registry_file)
+      ChefMetal.inline_resource(action_handler) do
+        file registry_file do
+          action :delete
+        end
+      end
+    end
+
+    def create_registration_file(action_handler, node, machine_options, new_machine_registry_match = false)
+
+      # if machine_options.has_key?("available") && machine_options["available"] == "false"
+      #   raise ""
+
+      node['normal']['provisioner_options']['machine_options']['available'] = machine_options["available"]
+
+      machine_registration_file = ::File.join(Chef::Resource::SshCluster.path, "#{machine_options['ip_address']}.json")
+
+      if new_machine_registry_match
+        # delete_registry_file = ::File.join(Chef::Resource::SshCluster.path, "#{machine_options_json['ipaddress']}.json")
+        delete_provider_registration_file(action_handler, machine_registration_file)
+      end
+
+      machine_options_json = JSON.pretty_generate(machine_options)
+
+      ChefMetal.inline_resource(action_handler) do
+        file machine_registration_file do
+          content machine_options_json
+        end
+      end
+
+    end
+
+    def match_machine_options_to_registered(ssh_cluster_path, machine_options)
+
+      ssh_cluster_machines = File.join(ssh_cluster_path, "*.json")
+
+      Dir.glob(ssh_cluster_machines).sort.each do |registered_machine_file|
+
+        # Not Available By Default.
+        # available_registered_machine = false
+        matched_machine_json = false unless matched_machine_json
+
+        ip_address_match  = false unless ip_address_match
+        mac_address_match = false unless mac_address_match
+        fqdn_match        = false unless fqdn_match
+        hostname_match    = false unless hostname_match
+        node_name_match   = false unless node_name_match
+
+
+        # Fail By Default.
+        will_work         = false
+        not_gonna_work    = false
+        # But Assume is Available till told its not
+        available_registered_machine = true unless (available_registered_machine == false)
+
+        registered_machine_json = JSON.parse(File.read(registered_machine_file))
+
+        ip_address_match  = (registered_machine_json['ip_address'] == machine_options['ip_address']) # rescue false
+        mac_address_match = (registered_machine_json['mac_address'] == machine_options['mac_address']) # rescue false
+        fqdn_match        = (registered_machine_json['fqdn'] == machine_options['fqdn']) # rescue false
+        hostname_match    = (registered_machine_json['hostname'] == machine_options['hostname']) # rescue false
+
+
+        registered_machine_json.each_pair do |k,v|
+
+          # Check if key name is 'available' and if key value is true or false
+          if k == "available"
+
+            available_registered_machine =
+              registered_machine_is_available?(v) if available_registered_machine
+
+          elsif k == "node_name"
+            if v == machine_options[k] && (!v.nil? || !v.empty?)
+              node_name_match = true
+            end
+          else
+            if machine_options.has_key?(k)
+              case v
+              when String
+                # see if registered_machine value equals value in machine_options
+                if v == machine_options[k] && !v.empty?
+                  will_work         = true
+                else
+                  not_gonna_work = true unless (v.empty? ||
+                                                machine_options[k].empty? ||
+                                                k == "password" )
+                end
+              when Array
+                Array(machine_options[k]).each do |sv|
+                  if v.include?(sv)
+                    will_work = true
+                  else
+                    not_gonna_work = true
+                  end
+                end
+              when Hash
+              else
+                Chef::Log.debug "NOTHING?"
+              end
+            end
+          end
+        end
+
+        # end
+        # else
+        #   puts "already registered"
+        # end
+
+        #
+        # So we looped through a registered machine and:
+        #
+        # - we matched
+        #
+        # - we fatally matched
+        #
+        # - or we got nothin and move on to the next loop
+        #
+
+        if (will_work == true) && (not_gonna_work == false) && (available_registered_machine == true)
+          matched_machine_json = true
+          # break
+        end
+
+        error_out = false unless error_out
+        error_message = 'We Matched' unless error_message
+        if ip_address_match
+          error_out = true unless available_registered_machine
+          error_message << ' IP,'
+        end
+
+        if fqdn_match
+          error_out = true unless available_registered_machine
+          error_message << ' FQDN,'
+        end
+
+        if mac_address_match
+          error_out = true unless available_registered_machine
+          error_message << ' MAC ADDRESS,'
+        end
+
+        if hostname_match
+          error_out = true unless available_registered_machine
+          error_message << ' HOSTNAME,'
+        end
+
+        if node_name_match
+          error_out = true unless available_registered_machine
+          error_message << ' NODE NAME,'
+        end
+
+        if error_out && !available_registered_machine
+          error_message << ' but they already exist.'
+          error_message << ' Aborting to avoid inconsistencies.'
+          raise error_message
+        end
+
+        ##
+        # did we decide it will work?
+        if matched_machine_json
+          # Strip out any erroneous empty hash keys
+          # so we don't overwrite non-empty registered values
+          # with empty passed values
+          stripped_machine_json = JSON.parse(machine_options.to_json).delete_if {
+          |k, v| v.empty? unless k == 'machine_types' }
+
+          new_registration_json = registered_machine_json.merge!(stripped_machine_json)
+
+          # We're off the market
+          set_available_to_false = { "available" => "false" }
+          @matched_machine_json = new_registration_json.merge!(JSON.parse(set_available_to_false.to_json))
+
+          return @matched_machine_json
+          break
+        else
+          # wah wah wah
+          @matched_machine_json = false
+        end
+      end
+      return @matched_machine_json
+    end
+  end
+end

data/lib/chef_metal_ssh/ssh_driver.rb

@@ -0,0 +1,388 @@
+require 'json'
+require 'resolv'
+require 'chef_metal/driver'
+require 'chef_metal/version'
+require 'chef_metal/machine/basic_machine'
+require 'chef_metal/machine/unix_machine'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal/transport/ssh'
+require 'chef_metal_ssh/machine_registry'
+require 'chef_metal_ssh/version'
+require 'chef/resource/ssh_cluster'
+require 'chef/provider/ssh_cluster'
+module ChefMetalSsh
+  # Provisions machines with ssh.
+  class SshDriver < ChefMetal::Driver
+
+    include ChefMetalSsh::MachineRegistry
+
+    # ## Parameters
+    # cluster_path - path to the directory containing the vagrant files, which
+    #                should have been created with the vagrant_cluster resource.
+
+    # Create a new ssh driver.
+    #
+    # ## Parameters
+    # cluster_path - path to the directory containing the vagrant files, which
+    #                should have been created with the vagrant_cluster resource.
+    def initialize(driver_url, config)
+      super
+      scheme, cluster_path = driver_url.split(':', 2)
+      @cluster_path = cluster_path
+    end
+
+    attr_reader :cluster_path
+
+    def self.from_url(driver_url, config)
+      SshDriver.new(driver_url, config)
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      scheme, cluster_path = driver_url.split(':', 2)
+      cluster_path = File.expand_path(cluster_path || File.join(Chef::Config.config_dir, 'metal_ssh'))
+      "ssh:#{cluster_path}"
+    end
+    # Acquire a machine, generally by provisioning it.  Returns a Machine
+    # object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.  The Machine object will have a
+    # "node" property which must be saved to the server (if it is any
+    # different from the original node object).
+    #
+    # ## Parameters
+    # action_handler - the action_handler object that provides context.
+    # node - node object (deserialized json) representing this machine.  If
+    #        the node has a provisioner_options hash in it, these will be used
+    #        instead of options provided by the provisioner.  TODO compare and
+    #        fail if different?
+    #        node will have node['normal']['provisioner_options'] in it with any options.
+    #        It is a hash with this format:
+    #
+    #           -- provisioner_url: ssh:<@target_host>
+    #           -- target_ip: the IP address of the target machine - IP or FQDN is required
+    #           -- target_fqdn: The Resolvable name of the target machine - IP or FQDN is required
+    #           -- ssh_user: the user to ssh as
+    #           -- ssh_options: options to pass the ssh command. available options are here - https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh.rb#L61
+    #
+    #        node['normal']['provisioner_output'] will be populated with information
+    #        about the created machine.  For ssh, it is a hash with this
+    #        format:
+    #
+    #           -- provisioner_url: ssh:<@target_host>
+    #           -- name: container name
+    #
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      # TODO verify that the existing provisioner_url in the node is the same as ours
+      ensure_ssh_cluster(action_handler)
+      target_name = machine_spec.name
+      target_file_path = File.join(cluster_path, "#{machine_spec.name}.json")
+
+
+      # Chef::Log.debug("======================================>")
+      # Chef::Log.debug("acquire_machine - provisioner_options.inspect: #{provisioner_options.inspect}")
+      # Chef::Log.debug("======================================>")
+
+      @target_host = get_target_connection_method(machine_options)
+
+      # Chef::Log.debug("======================================>")
+      # Chef::Log.debug("acquire_machine - target_host: #{@target_host}")
+      # Chef::Log.debug("======================================>")
+
+      # Set up Provisioner Output
+      # TODO - make url the chef server url path? maybe disk path if zero?
+      machine_spec.location = {
+        'driver_url' => driver_url,
+        'driver_version' => ChefMetalSsh::VERSION,
+        'target_name' => target_name,
+        'target_file_path' => target_file_path,
+        'allocated_at' => Time.now.utc.to_s
+      }
+
+      # Chef::Log.debug("======================================>")
+      # Chef::Log.debug("acquire_machine - machine_spec.inspect: #{machine_spec.inspect}")
+      # Chef::Log.debug("======================================>")
+
+
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
+    end
+
+    def connect_to_machine(machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
+    end
+    # # Connect to machine without acquiring it
+    # def connect_to_machine(node)
+
+    #   # Get Password If Needs To Be Got
+    #   provisioner_url = node['normal']['provisioner_output']['provisioner_url']
+    #   provisioner_path = provisioner_url.split(':', 2)[1].sub(/^\/\//, "")
+    #   existing_machine_options = JSON.parse(File.read(provisioner_path)) # rescue nil
+    #   node_machine_options = node['normal']['provisioner_options']['machine_options']
+    #   unless node_machine_options['password']
+    #     Chef::Log.debug "Password Not in Provisioner Machine Options"
+    #     node_machine_options['password'] = existing_machine_options['password'] ?
+    #       existing_machine_options['password'] : nil
+    #   end
+
+    #   # Get Some
+    #   machine_for(machine_spec, machine_options)
+    # end
+
+    # def delete_machine(action_handler, node)
+    #   convergence_strategy_for(node).delete_chef_objects(action_handler, node)
+    # end
+
+    # def stop_machine(action_handler, node)
+    #   #
+    #   # What to do What to do.
+    #   #
+    #   # On one level there's really only one thing to do here,
+    #   # shellout and halt, or shutdown -h now,
+    #   # maybe provide abitily to pass some shutdown options
+    #   #
+    #   # But be vewwy vewwy careful:
+    #   #
+    #   # you better have console...
+    #   # or be close to your datacenter
+    #   #
+    # end
+
+    # def restart_machine(action_handler, node)
+    #   # Full Restart, POST BIOS and all
+    # end
+
+    # def reload_machine(action_handler, node)
+    #   # Use `kexec` here to skip POST and BIOS and all that noise.
+    # end
+
+    def driver_url
+      "ssh:#{cluster_path}"
+    end
+
+
+    protected
+
+    def ensure_ssh_cluster(action_handler)
+      _cluster_path = cluster_path
+      ChefMetal.inline_resource(action_handler) do
+        ssh_cluster _cluster_path
+      end
+    end
+
+    def get_target_connection_method(given_machine_options)
+
+      machine_options = symbolize_keys(given_machine_options)
+
+      target_ip   = machine_options[:ip_address] || false
+      target_fqdn = machine_options[:fqdn]       || false
+
+      raise "no @target_host, target_ip or target_fqdn given" unless
+      ( @target_host || target_ip || target_fqdn )
+
+      remote_host = ''
+      if @target_host
+        remote_host = @target_host
+      elsif target_ip
+        raise 'Invalid IP' unless ( target_ip =~ Resolv::IPv4::Regex ||
+                                    target_ip =~ Resolv::IPv6::Regex )
+        remote_host = target_ip
+      elsif target_fqdn
+        rh = Resolv::Hosts.new
+        rd = Resolv.new
+
+        begin
+          rh.getaddress(target_fqdn)
+          in_hosts_file = true
+        rescue
+          in_hosts_file = false
+        end
+
+        begin
+          rd.getaddress(target_fqdn)
+          in_dns = true
+        rescue
+          in_dns = false
+        end
+
+        raise 'Unresolvable Hostname' unless ( in_hosts_file || in_dns )
+        remote_host = target_fqdn
+      else
+        raise "aint got no target yo, that dog dont hunt"
+      end
+
+      Chef::Log.debug("======================================>")
+      Chef::Log.debug("get_target_connection_method - remote_host: #{remote_host}")
+      Chef::Log.debug("======================================>")
+
+      remote_host
+    end
+
+    def machine_for(machine_spec, machine_options)
+      # ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
+      ChefMetal::Machine::UnixMachine.new(machine_spec,
+                                          create_ssh_transport(machine_options),
+                                          convergence_strategy_for(machine_spec, machine_options))
+    end
+
+    def transport_for(machine_options)
+      create_ssh_transport(machine_options)
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      @unix_convergence_strategy ||= begin
+        ChefMetal::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options],
+                                                          config)
+      end
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}){|result, (key, value)|
+
+        new_key   = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+
+        new_value = case value
+        when Hash
+          symbolize_keys(value)
+        else
+          value
+        end
+
+        result[new_key] = new_value
+        result
+
+      }
+    end
+
+    # Setup Ssh
+    def create_ssh_transport(machine_options)
+      machine_ssh_options = machine_options['ssh_options']
+
+      ##
+      # Ssh Username
+      username = machine_ssh_options['user'] || 'root'
+
+      Chef::Log.debug("======================================>")
+      Chef::Log.debug("create_ssh_transport - username: #{username}")
+      Chef::Log.debug("======================================>")
+
+      ##
+      # Ssh Password
+      ssh_pass = machine_ssh_options['password'] || false
+      if ssh_pass
+        ssh_pass_hash = Hash.new
+        ssh_pass_hash = { 'password' => ssh_pass }
+      else
+        Chef::Log.info("NO PASSWORD")
+      end
+
+      ##
+      # Ssh Key
+      ssh_keys = []
+      if machine_ssh_options['keys']
+        if machine_ssh_options['keys'].kind_of?(Array)
+          machine_ssh_options['keys'].each do |key|
+            ssh_keys << key
+          end
+        elsif machine_ssh_options['keys'].kind_of?(String)
+          ssh_keys << machine_ssh_options['keys']
+        else
+          ssh_keys = false
+        end
+      end
+
+      if ssh_keys
+        ssh_key_hash = Hash.new
+        ssh_key_hash = { 'keys' => ssh_keys }
+      end
+
+      Chef::Log.info("======================================>")
+      if ssh_pass
+        Chef::Log.info("create_ssh_transport - ssh_pass: #{ssh_pass_hash.inspect}")
+      elsif ssh_keys
+        Chef::Log.info("create_ssh_transport - ssh_key: #{ssh_keys.inpsect}")
+      else
+        Chef::Log.info("create_ssh_transport - no ssh_pass or ssh_key given")
+      end
+      Chef::Log.info("======================================>")
+
+      raise "no ssh_pass or ssh_key given" unless ( ssh_pass || ssh_keys )
+
+      machine_ssh_options = machine_ssh_options.merge!(ssh_pass_hash)
+      machine_ssh_options = machine_ssh_options.merge!(ssh_key_hash)
+
+      ##
+      # Valid Ssh Options
+      valid_ssh_options = [
+        :auth_methods, :bind_address, :compression, :compression_level, :config,
+        :encryption, :forward_agent, :hmac, :host_key,
+        :keepalive, :keepalive_interval, :kex, :keys, :key_data,
+        :languages, :logger, :paranoid, :password, :port, :proxy,
+        :rekey_blocks_limit,:rekey_limit, :rekey_packet_limit, :timeout, :verbose,
+        :global_known_hosts_file, :user_known_hosts_file, :host_key_alias,
+        :host_name, :user, :properties, :passphrase, :keys_only, :max_pkt_size,
+        :max_win_size, :send_env, :use_agent
+      ]
+
+      ##
+      # Ssh Options
+      ssh_options = symbolize_keys(machine_ssh_options)
+
+      # Validate Ssh Options
+      ssh_options.each { |k,v| raise 'Invalid Shh Option' unless valid_ssh_options.include?(k) }
+
+      Chef::Log.debug "======================================>"
+      Chef::Log.debug "create_ssh_transport - ssh_options: #{ssh_options.inspect}"
+      Chef::Log.debug "======================================>"
+
+      # Now That We Validated Options, Lets Get Our Target
+      @target_host = get_target_connection_method(machine_ssh_options)
+
+      # Make Sure We Can Connect
+      begin
+        ssh = Net::SSH.start(@target_host, username, ssh_options)
+        ssh.close
+        Chef::Log.debug("======================================>")
+        Chef::Log.debug("ABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}")
+        Chef::Log.debug("======================================>")
+      rescue
+        Chef::Log.debug("======================================>")
+        Chef::Log.debug("UNABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}")
+        Chef::Log.debug("======================================>")
+        raise "UNABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}"
+      end
+
+      ##
+      # Ssh Additional Options
+      options = {}
+
+      #Enable pty by default
+      options[:ssh_pty_enable] = true
+
+      # If we not root use sudo
+      if username != 'root'
+        options[:prefix] = 'sudo '
+      end
+
+      Chef::Log.debug("======================================>")
+      Chef::Log.debug("create_ssh_transport - options: #{options.inspect}")
+      Chef::Log.debug("======================================>")
+
+      ChefMetal::Transport::SSH.new(@target_host, username, ssh_options, options, config)
+
+      # We Duped It So Now We Can Zero the Node Attr. So Not Saved On Server
+      # provisioner_options['machine_options']['password'] =
+      #   nil if provisioner_options['machine_options']['password']
+
+      # provisioner_options['ssh_options']['password'] =
+      #   nil if provisioner_options['ssh_options']['password']
+
+    end
+
+  end
+end

data/lib/chef_metal_ssh/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalSsh
-  VERSION = "0.0.4"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-ssh
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-08 00:00:00.000000000 Z
+date: 2014-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
-  requirement: &13107560 !ruby/object:Gem::Requirement
+  requirement: &22050800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,21 +21,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13107560
+  version_requirements: *22050800
 - !ruby/object:Gem::Dependency
   name: chef-metal
-  requirement: &13163400 !ruby/object:Gem::Requirement
+  requirement: &22049540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.12'
   type: :runtime
   prerelease: false
-  version_requirements: *13163400
+  version_requirements: *22049540
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &13161940 !ruby/object:Gem::Requirement
+  requirement: &22068960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.5'
   type: :development
   prerelease: false
-  version_requirements: *13161940
+  version_requirements: *22068960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &13160480 !ruby/object:Gem::Requirement
+  requirement: &22068460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13160480
+  version_requirements: *22068460
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &13158020 !ruby/object:Gem::Requirement
+  requirement: &22067540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13158020
+  version_requirements: *22067540
 description: Provisioner for managing servers using ssh in Chef Metal.
 email: zackzondlo@gmail.com
 executables: []
@@ -77,10 +77,15 @@ files:
 - Rakefile
 - LICENSE.txt
 - README.md
-- lib/chef_metal/provisioner_init/ssh_init.rb
+- lib/chef/provider/ssh_cluster.rb
+- lib/chef/provider/ssh_target.rb
+- lib/chef/resource/ssh_cluster.rb
+- lib/chef/resource/ssh_target.rb
+- lib/chef_metal/driver_init/ssh.rb
 - lib/chef_metal_ssh.rb
-- lib/chef_metal_ssh/ssh_provisioner.rb
 - lib/chef_metal_ssh/version.rb
+- lib/chef_metal_ssh/ssh_driver.rb
+- lib/chef_metal_ssh/machine_registry.rb
 homepage: https://github.com/double-z/chef-metal-ssh
 licenses: []
 post_install_message: 

data/lib/chef_metal/provisioner_init/ssh_init.rb

@@ -1,4 +0,0 @@
-require 'chef_metal_ssh/ssh_provisioner'
-
-ChefMetal.add_registered_provisioner_class("ssh",
-  ChefMetalSsh::SshProvisioner)

data/lib/chef_metal_ssh/ssh_provisioner.rb

@@ -1,300 +0,0 @@
-require 'resolv'
-require 'chef_metal/provisioner'
-require 'chef_metal/version'
-require 'chef_metal/machine/basic_machine'
-require 'chef_metal/machine/unix_machine'
-require 'chef_metal/convergence_strategy/install_cached'
-require 'chef_metal/transport/ssh'
-
-module ChefMetalSsh
-  # Provisions machines with ssh.
-  class SshProvisioner < ChefMetal::Provisioner
-
-    def initialize()
-    end
-
-    # Acquire a machine, generally by provisioning it.  Returns a Machine
-    # object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.  The Machine object will have a
-    # "node" property which must be saved to the server (if it is any
-    # different from the original node object).
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that provides context.
-    # node - node object (deserialized json) representing this machine.  If
-    #        the node has a provisioner_options hash in it, these will be used
-    #        instead of options provided by the provisioner.  TODO compare and
-    #        fail if different?
-    #        node will have node['normal']['provisioner_options'] in it with any options.
-    #        It is a hash with this format:
-    #
-    #           -- provisioner_url: ssh:<@target_host>
-    #           -- target_ip: the IP address of the target machine - IP or FQDN is required
-    #           -- target_fqdn: The Resolvable name of the target machine - IP or FQDN is required
-    #           -- ssh_user: the user to ssh as
-    #           -- ssh_options: options to pass the ssh command. available options are here - https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh.rb#L61
-    #
-    #        node['normal']['provisioner_output'] will be populated with information
-    #        about the created machine.  For ssh, it is a hash with this
-    #        format:
-    #
-    #           -- provisioner_url: ssh:<@target_host>
-    #           -- name: container name
-    #
-    def acquire_machine(action_handler, node)
-      # TODO verify that the existing provisioner_url in the node is the same as ours
-
-      # Set up the modified node data
-      provisioner_options = node['normal']['provisioner_options']
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("acquire_machine - provisioner_options.inspect: #{provisioner_options.inspect}")
-      Chef::Log.debug("======================================>")
-
-      @target_host = get_target_connection_method(node)
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("acquire_machine - target_host: #{@target_host}")
-      Chef::Log.debug("======================================>")
-
-      # Set up Provisioner Output
-      # TODO - make url the chef server url path? maybe disk path if zero?
-      provisioner_output = node['normal']['provisioner_output'] || {
-        'provisioner_url' =>   "ssh:#{@target_host}",
-        'name' => node['name']
-      }
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("acquire_machine - provisioner_output.inspect: #{provisioner_output.inspect}")
-      Chef::Log.debug("======================================>")
-
-      node['normal']['provisioner_output'] = provisioner_output
-
-      # Create machine object for callers to use
-      machine_for(node)
-    end
-
-    # Connect to machine without acquiring it
-    def connect_to_machine(node)
-      @target_host = get_target_connection_method(node)
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("connect_to_machine - target_host: #{@target_host}")
-      Chef::Log.debug("======================================>")
-
-      machine_for(node)
-    end
-
-    def delete_machine(action_handler, node)
-      convergence_strategy_for(node).delete_chef_objects(action_handler, node)
-    end
-
-    def stop_machine(action_handler, node)
-      # What to do What to do.
-      # On one level there's really only one thing to do here,
-      # shellout and halt, or shutdown -h now,
-      # maybe provide abitily to pass some shutdown options
-      # But be vewwy vewwy careful, you better have console,
-      # or be close to your datacenter
-      true
-    end
-
-    def restart_machine(action_handler, node)
-      # Full Restart, POST BIOS and all
-    end
-
-    def reload_machine(action_handler, node)
-      # Use `kexec` here to skip POST and BIOS and all that noise.
-    end
-
-    # Not meant to be part of public interface
-    def transport_for(node)
-      create_ssh_transport(node)
-    end
-
-    protected
-
-    def get_target_connection_method(node)
-
-      provisioner_options = node['normal']['provisioner_options']
-
-      target_ip   = ''
-      target_ip   = provisioner_options['target_ip'] || nil
-
-      target_fqdn = ''
-      target_fqdn = provisioner_options['target_fqdn'] || nil
-
-      remote_host = ''
-      if @target_host
-        remote_host = @target_host
-      elsif target_ip
-        raise 'Invalid IP' unless ( target_ip =~ Resolv::IPv4::Regex ||
-                                    target_ip =~ Resolv::IPv6::Regex )
-        remote_host = target_ip
-      elsif target_fqdn
-        rh = Resolv::Hosts.new
-        rd = Resolv.new
-
-        begin
-          rh.getaddress(target_fqdn)
-          in_hosts_file = true
-        rescue
-          in_hosts_file = false
-        end
-
-        begin
-          rd.getaddress(target_fqdn)
-          in_dns = true
-        rescue
-          in_dns = false
-        end
-
-        raise 'Unresolvable Hostname' unless ( in_hosts_file || in_dns )
-        remote_host = target_fqdn
-      else
-        raise "aint got no target yo, that dog dont hunt"
-      end
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("get_target_connection_method - remote_host: #{remote_host}")
-      Chef::Log.debug("======================================>")
-
-      remote_host
-    end
-
-    def machine_for(node)
-      ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
-    end
-
-    def convergence_strategy_for(node)
-      @convergence_strategy ||= begin
-        ChefMetal::ConvergenceStrategy::InstallCached.new
-      end
-    end
-
-    def symbolize_keys(hash)
-      hash.inject({}){|result, (key, value)|
-        new_key = case key
-        when String then key.to_sym
-        else key
-        end
-        new_value = case value
-        when Hash then symbolize_keys(value)
-        else value
-        end
-        result[new_key] = new_value
-        result
-      }
-    end
-
-    # Setup Ssh
-    def create_ssh_transport(node)
-
-      provisioner_options     = node['normal']['provisioner_options']
-      provisioner_ssh_options = provisioner_options['ssh_options']
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("create_ssh_transport - target_host: #{@target_host}")
-      Chef::Log.debug("======================================>")
-
-      ##
-      # Ssh Username
-      username = ''
-      username = provisioner_options['ssh_user'] || 'vagrant'
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("create_ssh_transport - username: #{username}")
-      Chef::Log.debug("======================================>")
-
-      ##
-      # Ssh Password
-      ssh_pass = false
-      ssh_pass = provisioner_ssh_options['password'] if provisioner_ssh_options['password']
-      # ssh_pass = ssh_options[:password] if ssh_options[:password]
-
-      ##
-      # Ssh Key
-      ssh_key = false
-      ssh_key = provisioner_ssh_options['host_key'] if provisioner_ssh_options['host_key']
-
-      Chef::Log.debug("======================================>")
-      if ssh_pass
-        Chef::Log.debug("create_ssh_transport - ssh_pass: #{ssh_pass}")
-      elsif ssh_key
-        Chef::Log.debug("create_ssh_transport - ssh_key: #{ssh_key}")
-      else
-        Chef::Log.debug("create_ssh_transport - no ssh_pass or ssh_key given")
-      end
-      Chef::Log.debug("======================================>")
-
-      raise "no ssh_pass or ssh_key given" unless ( ssh_pass || ssh_key )
-      ##
-      # Ssh Main Options
-      valid_ssh_options = [
-        :auth_methods, :bind_address, :compression, :compression_level, :config,
-        :encryption, :forward_agent, :hmac, :host_key,
-        :keepalive, :keepalive_interval, :kex, :keys, :key_data,
-        :languages, :logger, :paranoid, :password, :port, :proxy,
-        :rekey_blocks_limit,:rekey_limit, :rekey_packet_limit, :timeout, :verbose,
-        :global_known_hosts_file, :user_known_hosts_file, :host_key_alias,
-        :host_name, :user, :properties, :passphrase, :keys_only, :max_pkt_size,
-        :max_win_size, :send_env, :use_agent
-      ]
-
-      ##
-      # Ssh Main Options
-      ssh_options = symbolize_keys(provisioner_ssh_options)
-
-      # Validate Ssh Options
-      ssh_options.each { |k,v| raise 'Invalid Shh Option' unless valid_ssh_options.include?(k) }
-
-      ##
-      # Ssh Main Options
-      # ssh_options = symbolize_keys(provisioner_ssh_options)
-      # ssh_options = {
-      #   # TODO create a user known hosts file
-      #   #          :user_known_hosts_file => provisioner_options['ssh_connect_options']['UserKnownHostsFile'],
-      #   #          :paranoid => true,
-      #   # :auth_methods => [ 'publickey' ],
-      #   :keys_only => false,
-      #   :host_key => ssh_key,
-      #   :password => ssh_pass
-      # }
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("create_ssh_transport - ssh_options: #{ssh_options.inspect}")
-      Chef::Log.debug("======================================>")
-
-      # Make Sure We Can Connect
-      begin
-        ssh = Net::SSH.start(@target_host, username, ssh_options)
-        ssh.close
-        Chef::Log.debug("======================================>")
-        Chef::Log.debug("ABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}")
-        Chef::Log.debug("======================================>")
-      rescue
-        Chef::Log.debug("======================================>")
-        Chef::Log.debug("UNABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}")
-        Chef::Log.debug("======================================>")
-        raise "UNABLE to Connect to #{@target_host} using #{username} and #{ssh_options.inspect}"
-      end
-
-      ##
-      # Ssh Additional Options
-      options = {}
-      #Enable pty by default
-      options[:ssh_pty_enable] = true
-
-      if username != 'root'
-        options[:prefix] = 'sudo '
-      end
-
-      Chef::Log.debug("======================================>")
-      Chef::Log.debug("create_ssh_transport - options: #{options.inspect}")
-      Chef::Log.debug("======================================>")
-
-      ChefMetal::Transport::SSH.new(@target_host, username, ssh_options, options)
-    end
-
-  end
-end