chef-provisioning-ssh 0.0.7 → 0.0.8.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8be4eea284f7d7404c6fb4465f3b0abf8906b4f
-  data.tar.gz: 64b5600e5aeb58326cdfc8622d00f5c696f12863
+  metadata.gz: f3271039d59883f27dc58d29d172f54d37aa72a2
+  data.tar.gz: eac579801f2bb8492c0bb74407a0f2baf082d4b7
 SHA512:
-  metadata.gz: 2604aabe0c9063ae30f99a712913bbe99415baa73d71f5f3f005506bb71e8c89176f6e9a4f55ae5b059e09402fab0089834229cd918fef5e7fb05abdea68eff5
-  data.tar.gz: cebce0acee1c06106a10fe291345d48766d86533e1e33ee8ff75ac118fae2071971784cbc8b81e73ac206006527ba878dddeb7cd0df61895f5757be7ea0c851a
+  metadata.gz: 47f9c741cf883fde0972e57c4e7083e8f95f3a822e2b860ae9b807004778cfa71b7e70643d32de443d02bab2762492ab472bfd096e25361e65eda3069ae46c2c
+  data.tar.gz: 76485ca7698c2e22c864801b6769a4f68a631ff8f7a334ff440711164565550e509cc38d692db52451ddc2d9852595cbf8b180e15d8d635bc7d91a777b8231dc

data/lib/chef/provisioning/ssh_driver/driver.rb

@@ -41,23 +41,31 @@ class Chef
         end
 
         def allocate_machine(action_handler, machine_spec, machine_options)
-          existing_machine = existing_ssh_machine(machine_spec)
-          if !existing_machine
-            validate_machine_options(action_handler, machine_spec, machine_options)
-            ensure_ssh_cluster(action_handler)
-            ssh_machine = create_ssh_machine(action_handler, machine_spec, machine_options)
+          existing_machine         = ssh_machine_exists?(machine_spec)
+          ssh_machine_file_updated = create_machine(action_handler, machine_spec, machine_options)
+
+          if !existing_machine || !machine_spec.location
             machine_spec.location = {
               'driver_url' => driver_url,
               'driver_version' => Chef::Provisioning::SshDriver::VERSION,
               'target_name' => machine_spec.name,
-              'ssh_machine_file' => ssh_machine,
-              'allocated_at' => Time.now.utc.to_s
+              'ssh_machine_file' => ssh_machine_file_updated,
+              'allocated_at' => Time.now.utc.to_s,
+              'updated_at' => Time.now.utc.to_s,
+              'host' => action_handler.host_node
             }
+          elsif ssh_machine_file_updated
+            machine_spec.location['updated_at'] = Time.now.utc.to_s
+          end
+
+          if machine_spec.location && (machine_spec.location['driver_version'] != Chef::Provisioning::SshDriver::VERSION)
+            machine_spec.location['driver_version'] = Chef::Provisioning::SshDriver::VERSION
           end
+
         end
 
         def ready_machine(action_handler, machine_spec, machine_options)
-          ssh_machine = existing_ssh_machine(machine_spec)
+          ssh_machine = existing_ssh_machine_to_sym(machine_spec)
 
           if !ssh_machine
             raise "SSH Machine #{machine_spec.name} does not have a machine file associated with it!"
@@ -68,21 +76,29 @@ class Chef
         end
 
         def connect_to_machine(machine_spec, machine_options)
-          machine_for(machine_spec, machine_options)
+          ssh_machine = existing_ssh_machine_to_sym(machine_spec)
+          machine_for(machine_spec, ssh_machine)
         end
 
         def destroy_machine(action_handler, machine_spec, machine_options)
-          ssh_machine = existing_ssh_machine(machine_spec)
+          ssh_machine = ssh_machine_exists?(machine_spec)
 
-          if !ssh_machine
+          if !ssh_machine || !::File.exists?(machine_spec.location['ssh_machine_file'])
             raise "SSH Machine #{machine_spec.name} does not have a machine file associated with it!"
-          end
+	  else
+            Chef::Provisioning.inline_resource(action_handler) do
+	      file machine_spec.location['ssh_machine_file'] do
+		action :delete
+		backup false
+	      end
+	    end 
+	  end
 
 
         end
 
         def stop_machine(action_handler, machine_spec, machine_options)
-          ssh_machine = existing_ssh_machine(machine_spec)
+          ssh_machine = existing_ssh_machine_to_sym(machine_spec)
 
           if !ssh_machine
             raise "SSH Machine #{machine_spec.name} does not have a machine file associated with it!"
@@ -92,13 +108,13 @@ class Chef
         end
 
         def machine_for(machine_spec, machine_options)
-          ssh_machine = existing_ssh_machine(machine_spec)
+          ssh_machine = existing_ssh_machine_to_sym(machine_spec)
 
           if !ssh_machine
             raise "SSH Machine #{machine_spec.name} does not have a machine file associated with it!"
           end
 
-          if ssh_machine[:is_windows]
+          if ssh_machine[:transport_options][:is_windows]
             Chef::Provisioning::Machine::WindowsMachine.new(machine_spec,
                                                             transport_for(ssh_machine),
                                                             convergence_strategy_for(ssh_machine))
@@ -110,7 +126,7 @@ class Chef
         end
 
         def transport_for(ssh_machine)
-          if ssh_machine[:is_windows]
+          if ssh_machine[:transport_options][:is_windows]
             create_winrm_transport(ssh_machine)
           else
             create_ssh_transport(ssh_machine)
@@ -118,31 +134,28 @@ class Chef
         end
 
         def convergence_strategy_for(ssh_machine)
-          if ssh_machine[:is_windows]
+          if ssh_machine[:transport_options][:is_windows]
             Chef::Provisioning::ConvergenceStrategy::InstallMsi.
-                new(ssh_machine[:convergence_options], config)
+              new(ssh_machine[:convergence_options], config)
           else
             Chef::Provisioning::ConvergenceStrategy::InstallSh.
-                new(ssh_machine[:convergence_options], config)
+              new(ssh_machine[:convergence_options], config)
           end
         end
 
         def create_ssh_transport(ssh_machine)
-          hostname = ssh_machine[:transport_options][:host] ||
-                     ssh_machine[:transport_options][:ip_address]
-          username = ssh_machine[:transport_options][:username]
-          ssh_options = ssh_machine[:transport_options][:ssh_options] ?
-                          ssh_machine[:transport_options][:ssh_options] : {}
-          options = ssh_machine[:transport_options][:options] ?
-                      ssh_machine[:transport_options][:options] : {}
+          hostname    = ssh_machine[:transport_options][:host]
+          username    = ssh_machine[:transport_options][:username]
+          ssh_options = ssh_machine[:transport_options][:ssh_options]
+          options     = ssh_machine[:transport_options][:options]
           Chef::Provisioning::Transport::SSH.new(hostname, username,
-                                                 ssh_options, {:prefix => 'sudo '}, config)
+                                                 ssh_options, options, config)
         end
 
         def create_winrm_transport(ssh_machine)
-          # TODO IPv6 loopback?  What do we do for that?
+          # # TODO IPv6 loopback?  What do we do for that?
           hostname = ssh_machine[:transport_options][:host] ||
-                     ssh_machine[:transport_options][:ip_address]
+            ssh_machine[:transport_options][:ip_address]
           port = ssh_machine[:transport_options][:port] || 5985
           # port = forwarded_ports[port] if forwarded_ports[port]
           endpoint = "http://#{hostname}:#{port}/wsman"
@@ -152,7 +165,6 @@ class Chef
             :pass => ssh_machine[:transport_options][:password],
             :disable_sspi => true
           }
-
           Chef::Provisioning::Transport::WinRM.new(endpoint, type, options, config)
         end
 
@@ -192,48 +204,48 @@ class Chef
 
               missing = req_and_valid_fields.flatten - machine_options[:transport_options].keys
 
-              for oof in one_of_fields
+              one_of_fields.each do |oof|
                 if oof == oof & missing
                   error_msgs << ":transport_options => :#{oof.join(" or :")} required."
                 end
                 missing -= oof
               end
 
-              for missed in missing do
+              missing.each do |missed|
                 error_msgs << ":transport_options => :#{missed} required."
                 valid = false
               end
 
               extras = machine_options[:transport_options].keys - req_and_valid_fields.flatten
 
-              for extra in extras do
-                error_msgs << ":transport_options => :#{extra} not allowed."
+              extras.each do |extra|
+                error_msgs << ":transport_options => :#{extra} not allowed." unless extra == :port
                 valid = false
               end
             else
               # Validate Unix Options
-              req_fields = [[:host, :ip_address], :username]
+              req_fields = [[:host, :hostname, :ip_address], :username]
               one_of_fields = req_fields.select{ |i| i.kind_of?(Array)}
 
               missing = req_fields.flatten - machine_options[:transport_options].keys
 
-              for oof in one_of_fields
+              one_of_fields.each do |oof|
                 if oof == oof & missing
                   error_msgs << ":transport_options => :#{oof.join(" or :")} required."
                 end
                 missing -= oof
               end
 
-              for missed in missing do
+              missing.each do |missed|
                 error_msgs << ":transport_options => :#{missed} required."
                 valid = false
               end
 
-              valid_fields = [:is_windows, :host, :ip_address, :username, :ssh_options, :options]
+              valid_fields = [:is_windows, :host, :hostname, :ip_address, :username, :ssh_options, :options]
 
               extras = machine_options[:transport_options].keys - valid_fields
 
-              for extra in extras do
+              extras.each do |extra|
                 error_msgs << ":transport_options => :#{extra} not allowed."
                 valid = false
               end
@@ -243,7 +255,7 @@ class Chef
 
                 extras = machine_options[:transport_options][:ssh_options].keys - valid_fields
 
-                for extra in extras do
+                extras.each do |extra|
                   error_msgs << ":transport_options => ssh_options => :#{extra} not allowed."
                   valid = false
                 end
@@ -254,7 +266,7 @@ class Chef
 
                 extras = machine_options[:transport_options][:options].keys - valid_fields
 
-                for extra in extras do
+                extras.each do |extra|
                   error_msgs << ":transport_options => :options => :#{extra} not allowed."
                   valid = false
                 end
@@ -264,7 +276,7 @@ class Chef
 
           if !valid
             exception_string = "Machine Options for #{machine_spec.name} are invalid cannot create machine."
-            for string in error_msgs do
+            error_msgs.each do |string|
               exception_string = "#{exception_string}\n  #{string}"
             end
             raise exception_string
@@ -273,17 +285,47 @@ class Chef
 
         def ensure_ssh_cluster(action_handler)
           _cluster_path = cluster_path
-          Chef::Provisioning.inline_resource(action_handler) do
-            ssh_cluster _cluster_path
+          unless ::File.exists?(_cluster_path)
+            Chef::Provisioning.inline_resource(action_handler) do
+              ssh_cluster _cluster_path
+            end
           end
         end
 
-        def create_ssh_machine(action_handler, machine_spec, machine_options)
+        def create_machine(action_handler, machine_spec, machine_options)
+          ensure_ssh_cluster(action_handler)
+
+          machine_options_hash_for_sym = deep_hashify(machine_options)
+          symbolized_machine_options   = symbolize_keys(machine_options_hash_for_sym)
+          validate_machine_options(action_handler, machine_spec, symbolized_machine_options)
+          # end
+
+
+          # def create_ssh_machine(action_handler, machine_spec, machine_options)
           log_info("File is = #{ssh_machine_file(machine_spec)}")
           log_info("current_machine_options = #{machine_options.to_s}")
+
+          machine_options_hash_for_s = deep_hashify(machine_options)
+          stringy_machine_options    = stringify_keys(machine_options_hash_for_s)
+          given_machine_options      = create_machine_hash(stringy_machine_options)
+
+          if ssh_machine_exists?(machine_spec)
+            existing_machine_hash = existing_ssh_machine(machine_spec)
+            if !existing_machine_hash.eql?(given_machine_options)
+              create_machine_file(action_handler, machine_spec, given_machine_options)
+            else
+              return false
+            end
+          else
+            file_updated = create_machine_file(action_handler, machine_spec, given_machine_options)
+            file_updated
+          end
+        end
+
+        def create_machine_file(action_handler, machine_spec, machine_options)
+          file_path = ssh_machine_file(machine_spec)
           machine_options_hash = deep_hashify(machine_options)
           stringy_machine_options = stringify_keys(machine_options_hash)
-          file_path = ssh_machine_file(machine_spec)
           options_parsed = ::JSON.parse(stringy_machine_options.to_json)
           json_machine_options = ::JSON.pretty_generate(options_parsed)
           Chef::Provisioning.inline_resource(action_handler) do
@@ -307,7 +349,16 @@ class Chef
         def existing_ssh_machine(machine_spec)
           if ssh_machine_exists?(machine_spec)
             existing_machine_hash = JSON.parse(File.read(ssh_machine_file(machine_spec)))
-            symbolize_keys(existing_machine_hash.to_hash)
+            existing_machine_hash.to_hash
+          else
+            return {}
+          end
+        end
+
+        def existing_ssh_machine_to_sym(machine_spec)
+          if ssh_machine_exists?(machine_spec)
+            existing_machine_hash = existing_ssh_machine(machine_spec)
+            symbolize_keys(existing_machine_hash)
           else
             return false
           end
@@ -329,6 +380,67 @@ class Chef
             ssh_machine_file
           end
         end
+
+        def create_machine_hash(machine_options)
+          if !machine_options['transport_options']['host']
+            machine_options['transport_options']['host'] = machine_options['transport_options']['ip_address'] ||
+              machine_options['transport_options']['hostname']
+          end
+          validate_transport_options_host(machine_options['transport_options']['host'])
+          unless machine_options['transport_options']['is_windows']
+            machine_options['transport_options']['options'] ||= {}
+            unless machine_options['transport_options']['username'] == 'root'
+              machine_options['transport_options']['options']['prefix'] = 'sudo '
+            end
+          end
+          ensure_has_keys_or_password(machine_options['transport_options'])
+          machine_options.to_hash
+        end
+
+        def ensure_has_keys_or_password(transport_hash)
+          if transport_hash['is_windows']
+            password = transport_hash['password'] || false
+            has_either = (password && password.kind_of?(String))
+          else
+            if transport_hash['ssh_options']
+              ssh_hash = transport_hash['ssh_options']
+              keys = ssh_hash['keys'] || false
+              password = ssh_hash['password'] || false
+              has_either = ((password && password.kind_of?(String)) ||
+                            (keys && !keys.empty? && keys.kind_of?(Array)))
+            else
+              has_either = false
+            end
+          end
+          raise 'No Keys OR Password, No Can Do Compadre' unless has_either
+          has_either
+        end
+
+        def validate_transport_options_host(target_host)
+          rh = Resolv::Hosts.new
+          rd = Resolv.new
+
+          begin
+            rh.getaddress(target_host)
+            in_hosts_file = true
+          rescue
+            in_hosts_file = false
+          end
+
+          begin
+            rd.getaddress(target_host)
+            in_dns = true
+          rescue
+            in_dns = false
+          end
+
+          valid_ip = ( target_host =~ Resolv::IPv4::Regex ||
+                       target_host =~ Resolv::IPv6::Regex )
+
+          raise 'Host is not a Valid IP or Resolvable Hostname' unless ( valid_ip || in_hosts_file || in_dns )
+        end
+
+
       end
     end
   end

data/lib/chef/provisioning/ssh_driver/version.rb

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module SshDriver
-      VERSION = '0.0.7'
+      VERSION = '0.0.8.rc.1'
     end
   end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-ssh
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8.rc.1
 platform: ruby
 authors:
 - Zack Zondlo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-07 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -98,9 +98,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.4