chef-provisioning-ssh 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d97758ed8f160bf3594de4ef5ca71e6f73b10766
-  data.tar.gz: 995af6965a59c982e8fbb3258145ddb74191aa24
+  metadata.gz: 69a88cd11bc933287de011039d2e16e43b4ffbc1
+  data.tar.gz: 5eea7c73c739a5b6927a87a3acafd1ae8e5ed9ee
 SHA512:
-  metadata.gz: 73f0585fc98cc33ce6717419e86e805eea247d138f510a11e8d045e3d200ccaab0c228f15de97a4934ccac501f04783585984330b803ab60ae65c60a4f577376
-  data.tar.gz: 590f81c78ebcd3b6ddf22e9961907c843a6bb734ab28ddca225edd14b2c4adacb47e13404203a1e7149b936909d28114050d7266e6d6ee16fc59ac57f0d018b9
+  metadata.gz: e9dce79bf1c666461cca81e59aa0e9a3aad48aa02f5d477114b14176aa5af3679e8edded22c25fd1fc981bda1db9950f17cf1566fa41387f3adbc3e7c0700331
+  data.tar.gz: 7be88e2785e107272b8459b27a13a79405c20ad50c1af8d207ed57bd9de4902ec459fd81d2132dc3537a8ff0ea15a42df73ff38329e8e4171e02698185471b41

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chef-provisioning-ssh.gemspec
+gemspec

data/README.md

@@ -1,181 +1,197 @@
-[![Gem Version](https://badge.fury.io/rb/chef-provisioning-ssh.svg)](http://badge.fury.io/rb/chef-provisioning-ssh)
-
 # Chef::Provisioning::Ssh
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/chef/chef-provisioning-ssh.svg?branch=master)](https://travis-ci.org/chef/chef-provisioning-ssh) [![Gem Version](https://badge.fury.io/rb/chef-provisioning-ssh.svg)](http://badge.fury.io/rb/chef-provisioning-ssh)
+
+Provisions existing machines using SSH.
 
 ## Installation
 
 Add this line to your application's Gemfile:
-e 
+
 ```ruby
 gem 'chef-provisioning-ssh'
 ```
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install chef-provisioning-ssh
+```
+$ gem install chef-provisioning-ssh
+```
 
 ## Usage
 
-The `machine_options` for provisioning ssh now use the key `transport_options` which line up directly with the `transport_options` for chef-provisioning proper. 
+### driver_url
 
-The `transport_options` key must be a *symbol*. 
+- `with_driver 'ssh'` will store machine data in a file in the directory `.chef/provisioning/ssh` on the provisioning machine, with a reference to the file in the node attribute `node['chef_provisioning']['reference']['ssh_machine_file']`
+- `with_driver 'ssh:/some/path'` will store machine data in the specified directory, with a reference to the file as above.
+- `with_driver 'ssh:chef'` will store all machine data in the node attribute `node['chef_provisioning']['reference']`.
 
-Sub-keys should be *strings*.
+### machine_options
 
-The transport_options can be viewed in the code for chef-provisioning here:
+The `machine_options` for provisioning ssh now use the key `transport_options` which line up directly with the `transport_options` for chef-provisioning proper.
 
-https://github.com/chef/chef-provisioning/blob/master/lib/chef/provisioning/transport/ssh.rb#L17-L34
-
-The snippet from that link is:
+The `transport_options` key and sub-keys may be strings or symbols.
 
-       - host: the host to connect to, e.g. '145.14.51.45'
-       - username: the username to connect with
-       - ssh_options: a list of options to Net::SSH.start
-       - options: a hash of options for the transport itself, including:
-         - :prefix: a prefix to send before each command (e.g. "sudo ")
-         - :ssh_pty_enable: set to false to disable pty (some instances don't
-           support this, most do)
-         - :ssh_gateway: the gateway to use, e.g. "jkeiser@145.14.51.45:222".
-           nil (the default) means no gateway. If the username is omitted,
-           then the default username is used instead (i.e. the user running
-           chef, or the username configured in .ssh/config).
-      
-       The options are used in
-         Net::SSH.start(host, username, ssh_options, options)
+The `transport_options` can be viewed in the code for chef-provisioning here:
 
-In addition to host, ip_address and hostname are also additional options.
+<https://github.com/chef/chef-provisioning/blob/master/lib/chef/provisioning/transport/ssh.rb#L17-L34>
 
-* the `ssh_options` key accepts options from Net::SSH.start, the full list can be seen here:
+The snippet from that link is:
 
-	http://net-ssh.github.io/ssh/v2/api/classes/Net/SSH.html#M000002
+```
+   - host: the host to connect to, e.g. '145.14.51.45'
+   - username: the username to connect with
+   - ssh_options: a list of options to Net::SSH.start
+   - options: a hash of options for the transport itself, including:
+     - :prefix: a prefix to send before each command (e.g. "sudo ")
+     - :ssh_pty_enable: set to false to disable pty (some instances don't
+       support this, most do)
+     - :ssh_gateway: the gateway to use, e.g. "jkeiser@145.14.51.45:222".
+       nil (the default) means no gateway. If the username is omitted,
+       then the default username is used instead (i.e. the user running
+       chef, or the username configured in .ssh/config).
+
+   The options are used in
+     Net::SSH.start(host, username, ssh_options, options)
+```
 
-* full machine_options for SSH example:
+In addition to host, ip_address and hostname are also additional options.
 
-        with_machine_options  :transport_options => {
-                'is_windows' => false,
-                'ip_address' => '192.168.33.23',
-                'host' => 'somehost',
-                'username' => 'vagrant',
-                'ssh_options' => {
-                    'auth_methods' => '', 
-                    'bind_address' => '',
-                    'compression' => '',
-                    'compression_level' => '',
-                    'config' => '',
-                    'encryption' => '',
-                    'forward_agent' => '',
-                    'hmac' => '',
-                    'host_key' => '',
-                    'keepalive' => '',
-                    'keepalive_interval' => '',
-                    'kex' => '',
-                    'keys' => ['/home/username/.vagrant.d/insecure_private_key'],
-                    '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' => ''
-                },
-                'options' => {
-                  'prefix' => 'sudo ',
-                  'ssh_pty_enable' => false,
-                  'ssh_gateway' => 'yourgateway'
-                }
-              }
-
-* full machine_options for WinRM example:
-
-        with_machine_options  :transport_options => {
-                    'is_windows' => true,
-                    'host' => '192.168.33.23',
-                    'port' => 5985,
-                    'username' => 'vagrant',
-                    'password' => 'vagrant'
-                }
-
-
-* machine resource example:
-
-			require 'chef/provisioning/ssh_driver'
-
-			with_driver 'ssh'
-
-			machine "ssh" do
-			  action [:ready, :setup, :converge]
-			  machine_options :transport_options => {
-			    'ip_address' => '192.168.33.22',
-			    'username' => 'vagrant',
-			    'ssh_options' => {
-			      'password' => 'vagrant'
-			    }
-			  }
-			  recipe 'vagrant::sshone'
-			  converge true
-			end
-
-            ##
-            # With WinRM you must use a remote chef-server
-            # local-mode chef server is not currently supported
-
-            with_chef_server "https://api.opscode.com/organizations/double-z",
-                             :client_name => Chef::Config[:node_name],
-                             :signing_key_filename => Chef::Config[:client_key]
-
-			machine "winrm" do
-			  action [:ready, :setup, :converge]
-			  machine_options :transport_options => {
-			    'is_windows' => true,
-			    'host' => '192.168.33.23',
+- the `ssh_options` key accepts options from Net::SSH.start, the full list can be seen here:
+
+  <http://net-ssh.github.io/ssh/v2/api/classes/Net/SSH.html#M000002>
+
+- full machine_options for SSH example:
+
+  ```ruby
+    with_machine_options  :transport_options => {
+            'is_windows' => false,
+            'ip_address' => '192.168.33.23',
+            'host' => 'somehost',
+            'username' => 'vagrant',
+            'ssh_options' => {
+                'auth_methods' => '',
+                'bind_address' => '',
+                'compression' => '',
+                'compression_level' => '',
+                'config' => '',
+                'encryption' => '',
+                'forward_agent' => '',
+                'hmac' => '',
+                'host_key' => '',
+                'keepalive' => '',
+                'keepalive_interval' => '',
+                'kex' => '',
+                'keys' => ['/home/username/.vagrant.d/insecure_private_key'],
+                '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' => ''
+            },
+            'options' => {
+              'prefix' => 'sudo ',
+              'ssh_pty_enable' => false,
+              'ssh_gateway' => 'yourgateway'
+            }
+          }
+  ```
+
+- full machine_options for WinRM example:
+
+  ```ruby
+    with_machine_options  :transport_options => {
+                'is_windows' => true,
+                'host' => '192.168.33.23',
                 'port' => 5985,
-			    'username' => 'vagrant',
-			    'password' => 'vagrant'
-			  }
-			  recipe 'windows'
-			  converge true
-			end
-
+                'username' => 'vagrant',
+                'password' => 'vagrant'
+            }
+  ```
+
+- machine resource example:
+
+  ```ruby
+        require 'chef/provisioning/ssh_driver'
+
+        with_driver 'ssh'
+
+        machine "ssh" do
+          action [:ready, :setup, :converge]
+          machine_options :transport_options => {
+            'ip_address' => '192.168.33.22',
+            'username' => 'vagrant',
+            'ssh_options' => {
+              'password' => 'vagrant'
+            }
+          }
+          recipe 'vagrant::sshone'
+          converge true
+        end
+
+        ##
+        # With WinRM you must use a remote chef-server
+        # local-mode chef server is not currently supported
+
+        with_chef_server "https://api.opscode.com/organizations/double-z",
+                         :client_name => Chef::Config[:node_name],
+                         :signing_key_filename => Chef::Config[:client_key]
+
+        machine "winrm" do
+          action [:ready, :setup, :converge]
+          machine_options :transport_options => {
+            'is_windows' => true,
+            'host' => '192.168.33.23',
+            'port' => 5985,
+            'username' => 'vagrant',
+            'password' => 'vagrant'
+          }
+          recipe 'windows'
+          converge true
+        end
+  ```
 
 To test it out, clone the repo:
 
-`git clone https://github.com/double-z/chef-provisioning-ssh.git`
+`git clone https://github.com/chef/chef-provisioning-ssh.git`
 
-in the test directory there is a Vagrantfile with 2 nodes. 
+in the test directory there is a Vagrantfile with 2 nodes.
 
 Run:
 
 `vagrant up`
 
-which will bring up both nodes. 
+which will bring up both nodes.
 
 Then run from the test directory:
 
-`chef-client -z -o vagrant::test_provisioning_ssh`
+`chef-client -z -o vagrant::test_ssh`
 
-NOTE: if the second machine fails it will be a result of issues with your vagrant key.
+NOTE: if the first machine fails it will likely be a result of issues with your vagrant key.
 
 This will run chef-provisioning on each of the two vagrant nodes.
 
@@ -183,9 +199,11 @@ thats it.
 
 party on wayne.
 
+Be aware, the `test_ssh` recipe is designed for testing, not to illustrate good practice. For example, you do not need to list all three actions `[ :ready, :setup, :converge ]` or specify `converge true` if you want the normal 'bootstrap if needed, converge if changed' behavior.
+
 ## Contributing
 
-1. Fork it ( http://github.com/double-z/chef-provisioning-ssh/fork )
+1. Fork it ( <http://github.com/chef/chef-provisioning-ssh/fork> )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/chef-provisioning-ssh.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef/provisioning/ssh_driver/version'
+
+Gem::Specification.new do |s|
+  s.name          = "chef-provisioning-ssh"
+  s.version       = Chef::Provisioning::SshDriver::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.author        = "Zack Zondlo"
+  s.email         = "zackzondlo@gmail.com"
+  s.extra_rdoc_files = ['README.md', 'LICENSE' ]
+  s.summary = 'Provisioner for managing servers using ssh in Chef Provisioning.'
+  s.description = s.summary
+  s.homepage = 'https://github.com/chef/chef-provisioning-ssh'
+
+  s.require_path  = "lib"
+  s.bindir       = "bin"
+  s.executables  = %w( )
+  s.files = %w(Rakefile LICENSE README.md Gemfile) + Dir.glob("*.gemspec") +
+      Dir.glob("{distro,lib,tasks,spec}/**/*", File::FNM_DOTMATCH).reject {|f| File.directory?(f) }
+
+  s.add_runtime_dependency "chef-provisioning", ">= 1.0", "< 3.0"
+
+  s.add_development_dependency "bundler", "~> 1.5"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+end

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

@@ -22,7 +22,13 @@ class Chef
 
         include Chef::Provisioning::SshDriver::Helpers
 
+        # cluster_path is where the driver stores machine data unless use_chef_store is true
         attr_reader :cluster_path
+        
+        # use_chef_store is true if the driver_url is 'ssh:chef'
+        # In this case, machine data is stored in chef
+        # under node['chef_provisioning']['reference']['machine_options']
+        attr_reader :use_chef_store
 
         def self.from_url(driver_url, config)
           Driver.new(driver_url, config)
@@ -32,43 +38,44 @@ class Chef
           super(driver_url, config)
           scheme, cluster_path = driver_url.split(':', 2)
           @cluster_path = cluster_path
+          @use_chef_store = cluster_path == 'chef' 
         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, 'provisioning/ssh'))
+          unless cluster_path == 'chef'
+            cluster_path = File.expand_path(cluster_path || File.join(Chef::Config.config_dir, 'provisioning/ssh'))
+          end
           "ssh:#{cluster_path}"
         end
 
         def allocate_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 = {
+          ssh_machine_options = prepare_machine_options(action_handler, machine_spec, machine_options)
+          log_info("current_machine_options = #{ssh_machine_options.to_s}")
+          
+          unless ssh_machine_exists?(machine_spec)
+            machine_spec.reference = {
               'driver_url' => driver_url,
               'driver_version' => Chef::Provisioning::SshDriver::VERSION,
               'target_name' => machine_spec.name,
-              '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
+          
+          update_ssh_machine(action_handler, machine_spec, ssh_machine_options)
 
-          if machine_spec.location && (machine_spec.location['driver_version'] != Chef::Provisioning::SshDriver::VERSION)
-            machine_spec.location['driver_version'] = Chef::Provisioning::SshDriver::VERSION
+          if machine_spec.reference && 
+            (machine_spec.reference['driver_version'] != Chef::Provisioning::SshDriver::VERSION)
+            machine_spec.reference['driver_version'] = Chef::Provisioning::SshDriver::VERSION
           end
-
         end
 
         def ready_machine(action_handler, machine_spec, machine_options)
           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!"
+          unless ssh_machine
+            raise "SSH Machine #{machine_spec.name} does not have machine options associated with it!"
           end
 
           wait_for_transport(action_handler, ssh_machine, machine_spec, machine_options)
@@ -83,25 +90,25 @@ class Chef
         def destroy_machine(action_handler, machine_spec, machine_options)
           ssh_machine = ssh_machine_exists?(machine_spec)
 
-          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!"
-	  else
+          unless ssh_machine
+            raise "SSH Machine #{machine_spec.name} does not have machine options associated with it!"
+          end
+          
+          unless use_chef_store
             Chef::Provisioning.inline_resource(action_handler) do
-	      file machine_spec.location['ssh_machine_file'] do
-		action :delete
-		backup false
-	      end
-	    end 
-	  end
-
-
+              file machine_spec.reference['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_to_sym(machine_spec)
 
-          if !ssh_machine
-            raise "SSH Machine #{machine_spec.name} does not have a machine file associated with it!"
+          unless ssh_machine && machine_spec.reference['machine_options']
+            raise "SSH Machine #{machine_spec.name} does not have machine options associated with it!"
           end
 
           action_handler.report_progress("SSH Machine #{machine_spec.name} is existing hardware login and power off.")
@@ -110,8 +117,8 @@ class Chef
         def machine_for(machine_spec, machine_options)
           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!"
+          unless ssh_machine
+            raise "SSH Machine #{machine_spec.name} does not have machine options associated with it!"
           end
 
           if ssh_machine[:transport_options][:is_windows]
@@ -189,65 +196,65 @@ class Chef
           end
         end
 
+        def validate_transport_fields(options, req_fields, opt_fields)
+          error_msgs = []
+          valid_fields = req_fields.flatten + opt_fields
+          one_of_fields = req_fields.select{ |i| i.kind_of?(Array)}
+
+          missing = req_fields.flatten - options.keys
+
+          one_of_fields.each do |oof|
+            if oof == oof & missing
+              error_msgs << ":transport_options => :#{oof.join(" or :")} required."
+            end
+            missing -= oof
+          end
+
+          missing.each do |missed|
+            error_msgs << ":transport_options => :#{missed} required."
+            valid = false
+          end
+
+          extras = options.keys - valid_fields
+
+          extras.each do |extra|
+            error_msgs << ":transport_options => :#{extra} not allowed."
+            valid = false
+          end
+          
+          error_msgs
+        end
+        
         def validate_machine_options(action_handler, machine_spec, machine_options)
           error_msgs = []
           valid = true
-
-          if !machine_options[:transport_options]
+          
+          unless machine_options[:transport_options]
             error_msgs << ":transport_options required."
             valid = false
           else
             if machine_options[:transport_options][:is_windows]
               # Validate Windows Options.
-              req_and_valid_fields = [:is_windows, [:host, :ip_address], :username, :password]
-              one_of_fields = req_and_valid_fields.select{ |i| i.kind_of?(Array)}
-
-              missing = req_and_valid_fields.flatten - machine_options[:transport_options].keys
-
-              one_of_fields.each do |oof|
-                if oof == oof & missing
-                  error_msgs << ":transport_options => :#{oof.join(" or :")} required."
-                end
-                missing -= oof
-              end
-
-              missing.each do |missed|
-                error_msgs << ":transport_options => :#{missed} required."
-                valid = false
-              end
-
-              extras = machine_options[:transport_options].keys - req_and_valid_fields.flatten
-
-              extras.each do |extra|
-                error_msgs << ":transport_options => :#{extra} not allowed." unless extra == :port
+              field_errors = validate_transport_fields(
+                machine_options[:transport_options],
+                [:is_windows, [:host, :ip_address], :username, :password], 
+                [:port]
+              )
+              unless field_errors.empty?
                 valid = false
+                error_msgs << field_errors
               end
             else
               # Validate Unix Options
-              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
-
-              one_of_fields.each do |oof|
-                if oof == oof & missing
-                  error_msgs << ":transport_options => :#{oof.join(" or :")} required."
-                end
-                missing -= oof
-              end
-
-              missing.each do |missed|
-                error_msgs << ":transport_options => :#{missed} required."
-                valid = false
-              end
-
-              valid_fields = [:is_windows, :host, :hostname, :ip_address, :username, :ssh_options, :options]
-
-              extras = machine_options[:transport_options].keys - valid_fields
-
-              extras.each do |extra|
-                error_msgs << ":transport_options => :#{extra} not allowed."
+              field_errors = validate_transport_fields(
+                machine_options[:transport_options],
+                [[:host, :hostname, :ip_address], :username], 
+                [:is_windows, :host, :hostname, :ip_address, :username, :ssh_options, :options]
+              )
+              
+              unless field_errors.empty?
                 valid = false
+                error_msgs << field_errors
               end
 
               if machine_options[:transport_options][:ssh_options]
@@ -262,7 +269,7 @@ class Chef
               end
 
               if machine_options[:transport_options][:options]
-                valid_fields = [:prefix, :ssh_pty_enable, :ssh_gateway]
+                valid_fields = [:prefix, :ssh_pty_enable, :ssh_gateway, :scp_temp_dir]
 
                 extras = machine_options[:transport_options][:options].keys - valid_fields
 
@@ -292,42 +299,14 @@ class Chef
           end
         end
 
-        def create_machine(action_handler, machine_spec, machine_options)
+        def create_machine_file(action_handler, machine_spec, machine_options_hash)
           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)
           options_parsed = ::JSON.parse(stringy_machine_options.to_json)
           json_machine_options = ::JSON.pretty_generate(options_parsed)
+          log_info("File is = #{file_path}")
           Chef::Provisioning.inline_resource(action_handler) do
             file file_path do
               content json_machine_options
@@ -347,12 +326,15 @@ class Chef
         end
 
         def existing_ssh_machine(machine_spec)
-          if ssh_machine_exists?(machine_spec)
-            existing_machine_hash = JSON.parse(File.read(ssh_machine_file(machine_spec)))
-            existing_machine_hash.to_hash
-          else
+          unless ssh_machine_exists?(machine_spec)
             return {}
           end
+          
+          if use_chef_store
+            machine_spec.reference['machine_options']
+          else
+            JSON.parse(File.read(ssh_machine_file(machine_spec))).to_hash
+          end
         end
 
         def existing_ssh_machine_to_sym(machine_spec)
@@ -365,22 +347,47 @@ class Chef
         end
 
         def ssh_machine_exists?(machine_spec)
-          if machine_spec.location
-            ::File.exists?(ssh_machine_file(machine_spec))
+          if use_chef_store
+            machine_spec.reference && machine_spec.reference['machine_options']
           else
-            false
+            machine_spec.reference && ::File.exists?(ssh_machine_file(machine_spec))
           end
         end
 
         def ssh_machine_file(machine_spec)
-          if machine_spec.location && machine_spec.location['ssh_machine_file']
-            machine_spec.location['ssh_machine_file']
+          if machine_spec.reference && machine_spec.reference['ssh_machine_file']
+            machine_spec.reference['ssh_machine_file']
           else
             ssh_machine_file = ::File.join(@cluster_path, "#{machine_spec.name}.json")
             ssh_machine_file
           end
         end
 
+        def prepare_machine_options(action_handler, machine_spec, machine_options)
+          options_hash = symbolize_keys(deep_hashify(machine_options))
+          
+          # if no transport options are specified, use the existing ones
+          unless options_hash[:transport_options]
+            ssh_machine = existing_ssh_machine_to_sym(machine_spec) || {}
+            options_hash[:transport_options] = ssh_machine[:transport_options]  || {}
+          end
+          
+          validate_machine_options(action_handler, machine_spec, options_hash)
+          create_machine_hash(stringify_keys(options_hash))
+        end
+        
+        def update_ssh_machine(action_handler, machine_spec, ssh_machine_options)
+          unless existing_ssh_machine(machine_spec).eql? ssh_machine_options
+            if use_chef_store
+              machine_spec.reference['machine_options'] = ssh_machine_options
+            else
+              machine_spec.reference['ssh_machine_file'] = 
+                create_machine_file(action_handler, machine_spec, ssh_machine_options)
+            end
+            machine_spec.reference['updated_at'] = Time.now.utc.to_s
+          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'] ||
@@ -390,7 +397,7 @@ class Chef
           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 '
+              machine_options['transport_options']['options']['prefix'] ||= 'sudo '
             end
           end
           ensure_has_keys_or_password(machine_options['transport_options'])
@@ -405,9 +412,11 @@ class Chef
             if transport_hash['ssh_options']
               ssh_hash = transport_hash['ssh_options']
               keys = ssh_hash['keys'] || false
+              key_data = ssh_hash['key_data'] || false
               password = ssh_hash['password'] || false
               has_either = ((password && password.kind_of?(String)) ||
-                            (keys && !keys.empty? && keys.kind_of?(Array)))
+                            (keys && !keys.empty? && keys.kind_of?(Array)) ||
+                            (key_data && !key_data.empty? && key_data.kind_of?(Array)))
             else
               has_either = false
             end
@@ -439,8 +448,6 @@ class Chef
 
           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.9'
+      VERSION = '0.1.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-ssh
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Zack Zondlo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-26 00:00:00.000000000 Z
+date: 2016-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
@@ -16,14 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -74,9 +80,11 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- chef-provisioning-ssh.gemspec
 - lib/chef/provider/ssh_cluster.rb
 - lib/chef/provisioning/driver_init/ssh.rb
 - lib/chef/provisioning/ssh_driver.rb
@@ -84,7 +92,7 @@ files:
 - lib/chef/provisioning/ssh_driver/helpers.rb
 - lib/chef/provisioning/ssh_driver/version.rb
 - lib/chef/resource/ssh_cluster.rb
-homepage: https://github.com/double-z/chef-provisioning-ssh
+homepage: https://github.com/chef/chef-provisioning-ssh
 licenses: []
 metadata: {}
 post_install_message: 
@@ -103,9 +111,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Provisioner for managing servers using ssh in Chef Provisioning.
 test_files: []
-has_rdoc: