chef-provisioning-fog 0.26.1 → 0.26.3

data/lib/chef/provisioning/fog_driver/providers/xenserver.rb

@@ -1,11 +1,10 @@
-#fog:XenServer:<XenServer IP>
+# fog:XenServer:<XenServer IP>
 class Chef
   module Provisioning
     module FogDriver
       module Providers
         class XenServer < FogDriver::Driver
-
-          Driver.register_provider_class('XenServer', FogDriver::Providers::XenServer)
+          Driver.register_provider_class("XenServer", FogDriver::Providers::XenServer)
 
           def creator
             compute_options[:xenserver_username]
@@ -13,15 +12,14 @@ class Chef
 
           def bootstrap_options_for(machine_spec, machine_options)
             bootstrap_options = super
-            bootstrap_options[:tags] = bootstrap_options[:tags].map {|k,v| "#{k}: #{v}" }
+            bootstrap_options[:tags] = bootstrap_options[:tags].map { |k, v| "#{k}: #{v}" }
             bootstrap_options
           end
 
-          def ssh_options_for(machine_spec, machine_options, server)
-            { auth_methods: [ 'password' ],
+          def ssh_options_for(_machine_spec, machine_options, _server)
+            { auth_methods: ["password"],
               timeout: (machine_options[:ssh_timeout] || 600),
-              password: machine_options[:ssh_password]
-            }.merge(machine_options[:ssh_options] || {})
+              password: machine_options[:ssh_password] }.merge(machine_options[:ssh_options] || {})
           end
 
           def self.compute_options_for(provider, id, config)
@@ -29,12 +27,12 @@ class Chef
             new_compute_options[:provider] = provider
             new_config = { driver_options: { compute_options: new_compute_options } }
             new_defaults = {
-                driver_options: { compute_options: {} },
-                machine_options: { bootstrap_options: { affinity: id } }
+              driver_options: { compute_options: {} },
+              machine_options: { bootstrap_options: { affinity: id } }
             }
             result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
 
-            new_compute_options[:xenserver_url] = id if id && id != ''
+            new_compute_options[:xenserver_url] = id if id && id != ""
             credential = Fog.credentials
 
             new_compute_options[:xenserver_username] ||= credential[:xenserver_username]
@@ -50,9 +48,7 @@ class Chef
 
           def server_for(machine_spec)
             if machine_spec.reference
-              compute.servers.get(compute.get_by_uuid(machine_spec.reference['server_id'], 'VM'))
-            else
-              nil
+              compute.servers.get(compute.get_by_uuid(machine_spec.reference["server_id"], "VM"))
             end
           end
 
@@ -60,10 +56,10 @@ class Chef
             result = {}
             specs_and_options.each do |machine_spec, _machine_options|
               if machine_spec.reference
-                if machine_spec.reference['driver_url'] != driver_url
+                if machine_spec.reference["driver_url"] != driver_url
                   raise "Switching a machine's driver from #{machine_spec.reference['driver_url']} to #{driver_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
                 end
-                result[machine_spec] = compute.servers.get(compute.get_by_uuid(machine_spec.reference['server_id'], 'VM'))
+                result[machine_spec] = compute.servers.get(compute.get_by_uuid(machine_spec.reference["server_id"], "VM"))
               else
                 result[machine_spec] = nil
               end
@@ -72,29 +68,28 @@ class Chef
           end
 
           def create_many_servers(num_servers, bootstrap_options, parallelizer)
-            parallelizer.parallelize(1.upto(num_servers)) do |i|
+            parallelizer.parallelize(1.upto(num_servers)) do |_i|
               compute.default_template = bootstrap_options[:template] if bootstrap_options[:template]
-              raise 'No server can be created without a template, please set a template name as bootstrap_options' unless compute.default_template
+              raise "No server can be created without a template, please set a template name as bootstrap_options" unless compute.default_template
               server = compute.default_template.clone bootstrap_options[:name]
 
               if bootstrap_options[:affinity]
                 host = compute.hosts.all.select { |h| h.address == bootstrap_options[:affinity] }.first
-                if !host
+                unless host
                   raise "Host with ID #{bootstrap_options[:affinity]} not found."
                 end
                 server.affinity = host.reference
               end
 
-
               unless bootstrap_options[:memory].nil?
                 mem = (bootstrap_options[:memory].to_i * 1024 * 1024).to_s
-                server.set_attribute 'memory_limits', mem, mem, mem, mem
+                server.set_attribute "memory_limits", mem, mem, mem, mem
               end
 
               unless bootstrap_options[:cpus].nil?
                 cpus = (bootstrap_options[:cpus]).to_s
-                server.set_attribute 'VCPUs_max', cpus
-                server.set_attribute 'VCPUs_at_startup', cpus
+                server.set_attribute "VCPUs_max", cpus
+                server.set_attribute "VCPUs_at_startup", cpus
               end
 
               # network configuration through xenstore
@@ -103,33 +98,30 @@ class Chef
                 network = bootstrap_options[:network]
                 net_names = network[:vifs]
                 if net_names
-                  server.vifs.each {|x| x.destroy }
+                  server.vifs.each(&:destroy)
                   compute.networks.select { |net| Array(net_names).include? net.name }.each do |net|
                     compute.vifs.create vm: server, network: net, device: "0"
                   end
                 end
-                attrs['vm-data/ip'] = network[:vm_ip] if network[:vm_ip]
-                attrs['vm-data/gw'] = network[:vm_gateway] if network[:vm_gateway]
-                attrs['vm-data/nm'] = network[:vm_netmask] if network[:vm_netmask]
-                attrs['vm-data/ns'] = network[:vm_dns] if network[:vm_dns]
-                attrs['vm-data/dm'] = network[:vm_domain] if network[:vm_domain]
-                if !attrs.empty?
-                  server.set_attribute 'xenstore_data', attrs
-                end
+                attrs["vm-data/ip"] = network[:vm_ip] if network[:vm_ip]
+                attrs["vm-data/gw"] = network[:vm_gateway] if network[:vm_gateway]
+                attrs["vm-data/nm"] = network[:vm_netmask] if network[:vm_netmask]
+                attrs["vm-data/ns"] = network[:vm_dns] if network[:vm_dns]
+                attrs["vm-data/dm"] = network[:vm_domain] if network[:vm_domain]
+                server.set_attribute "xenstore_data", attrs unless attrs.empty?
               end
 
               userdevice = 1
-              (bootstrap_options[:additional_disks] || Hash.new).each do |name, data|
+              (bootstrap_options[:additional_disks] || {}).each do |name, data|
                 sr_name = data[:sr]
                 storage_repository = compute.storage_repositories.find { |sr| sr.name == sr_name }
-                raise 'You must specify sr name to add additional disks' unless storage_repository
-                raise 'You must specify size to add additional disk' unless data[:size]
+                raise "You must specify sr name to add additional disks" unless storage_repository
+                raise "You must specify size to add additional disk" unless data[:size]
 
                 gb   = 1_073_741_824
                 size = data[:size].to_i * gb
 
-
-                vdi_params = { name: name}
+                vdi_params = { name: name }
                 vdi_params[:storage_repository] = storage_repository
                 vdi_params[:description] == data[:description] if data[:description]
                 vdi_params[:virtual_size] = size.to_s
@@ -137,7 +129,6 @@ class Chef
 
                 compute.vbds.create vm: server, vdi: vdi, userdevice: userdevice.to_s, bootable: false
                 userdevice += 1
-
               end
 
               server.provision
@@ -147,10 +138,10 @@ class Chef
           end
 
           def start_server(action_handler, machine_spec, server)
-            if server.state == 'Halted'
+            if server.state == "Halted"
               action_handler.perform_action "start machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
                 server.start
-                machine_spec.reference['started_at'] = Time.now.to_i
+                machine_spec.reference["started_at"] = Time.now.to_i
               end
               machine_spec.save(action_handler)
             end
@@ -165,9 +156,8 @@ class Chef
   end
 end
 
-
 # Add methods required by the fog driver to XenServer's Server class
-require 'fog/compute/models/server'
+require "fog/compute/models/server"
 module Fog
   module Compute
     class XenServer
@@ -182,15 +172,15 @@ module Fog
           end
 
           def public_ip_address
-            if xenstore_data['vm-data/ip']
-              xenstore_data['vm-data/ip']
+            if xenstore_data["vm-data/ip"]
+              xenstore_data["vm-data/ip"]
             else
               wait_for { tools_installed? }
               if tools_installed?
                 guest_metrics.networks.first[1]
               else
-                fail 'Unable to return IP address. Virtual machine does not ' \
-                'have XenTools installed or a timeout occurred.'
+                raise "Unable to return IP address. Virtual machine does not " \
+                "have XenTools installed or a timeout occurred."
               end
             end
           end
@@ -213,36 +203,33 @@ end
 module Fog
   module XenServer
     class Connection
-      require 'xmlrpc/client'
+      require "xmlrpc/client"
       attr_reader :credentials
 
       def request(options, *params)
-        begin
-          parser = options.delete(:parser)
-          method = options.delete(:method)
-
-          if params.empty?
-            response = @factory.call_async(method, @credentials)
+        parser = options.delete(:parser)
+        method = options.delete(:method)
+
+        if params.empty?
+          response = @factory.call_async(method, @credentials)
+        else
+          if params.length.eql?(1) && params.first.is_a?(Hash)
+            response = @factory.call_async(method, @credentials, params.first)
+          elsif params.length.eql?(2) && params.last.is_a?(Array)
+            response = @factory.call_async(method, @credentials, params.first, params.last)
           else
-            if params.length.eql?(1) and params.first.is_a?(Hash)
-              response = @factory.call_async(method, @credentials, params.first)
-            elsif params.length.eql?(2) and params.last.is_a?(Array)
-              response = @factory.call_async(method, @credentials, params.first, params.last)
-            else
-              response = eval("@factory.call_async('#{method}', '#{@credentials}', #{params.map { |p| p.is_a?(String) ? "'#{p}'" : p }.join(',')})")
-            end
+            response = eval("@factory.call_async('#{method}', '#{@credentials}', #{params.map { |p| p.is_a?(String) ? "'#{p}'" : p }.join(',')})")
           end
-          raise RequestFailed.new("#{method}: " + response["ErrorDescription"].to_s) unless response["Status"].eql? "Success"
-          if parser
-            parser.parse(response["Value"])
-            response = parser.response
-          end
-
-          response
         end
+        raise RequestFailed, "#{method}: " + response["ErrorDescription"].to_s unless response["Status"].eql? "Success"
+        if parser
+          parser.parse(response["Value"])
+          response = parser.response
+        end
+
+        response
       end
     end
-
   end
 end
 
@@ -250,7 +237,7 @@ module Fog
   class Logger
     def self.deprecation(message)
       # Silence...ahh
-      Chef::Log.debug('Fog: ' + message)
+      Chef::Log.debug("Fog: " + message)
     end
   end
 end

data/lib/chef/provisioning/fog_driver/recipe_dsl.rb

@@ -1,38 +1,37 @@
-require 'chef/provisioning/fog_driver/driver'
-require 'chef/resource/fog_key_pair'
-require 'chef/provider/fog_key_pair'
-require 'chef/resource/scaleway_volume'
-require 'chef/provider/scaleway_volume'
+require "chef/provisioning/fog_driver/driver"
+require "chef/resource/fog_key_pair"
+require "chef/provider/fog_key_pair"
+require "chef/resource/scaleway_volume"
+require "chef/provider/scaleway_volume"
 
 class Chef
   module DSL
     module Recipe
       def with_fog_driver(provider, driver_options = nil, &block)
-        config = Cheffish::MergedConfig.new({ :driver_options => driver_options }, run_context.config)
+        config = Cheffish::MergedConfig.new({ driver_options: driver_options }, run_context.config)
         driver = Driver.from_provider(provider, config)
         run_context.chef_provisioning.with_driver(driver, &block)
       end
 
       def with_fog_ec2_driver(driver_options = nil, &block)
-        with_fog_driver('AWS', driver_options, &block)
+        with_fog_driver("AWS", driver_options, &block)
       end
 
       def with_fog_openstack_driver(driver_options = nil, &block)
-        with_fog_driver('OpenStack', driver_options, &block)
+        with_fog_driver("OpenStack", driver_options, &block)
       end
 
       def with_fog_rackspace_driver(driver_options = nil, &block)
-        with_fog_driver('Rackspace', driver_options, &block)
+        with_fog_driver("Rackspace", driver_options, &block)
       end
 
       def with_fog_vcair_driver(driver_options = nil, &block)
-        with_fog_driver('vcair', driver_options, &block)
+        with_fog_driver("vcair", driver_options, &block)
       end
 
       def with_fog_scaleway_driver(driver_options = nil, &block)
-        with_fog_driver('Scaleway', driver_options, &block)
+        with_fog_driver("Scaleway", driver_options, &block)
       end
-
     end
   end
 end

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

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module FogDriver
-      VERSION = '0.26.1'
+      VERSION = "0.26.3".freeze
     end
   end
 end

data/lib/chef/resource/fog_key_pair.rb

@@ -1,7 +1,7 @@
-require 'chef/provisioning'
+require "chef/provisioning"
 
 class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
-  self.resource_name = 'fog_key_pair'
+  self.resource_name = "fog_key_pair"
 
   def initialize(*args)
     super
@@ -13,14 +13,14 @@ class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
 
   attribute :driver
   # Private key to use as input (will be generated if it does not exist)
-  attribute :private_key_path, :kind_of => String
+  attribute :private_key_path, kind_of: String
   # Public key to use as input (will be generated if it does not exist)
-  attribute :public_key_path, :kind_of => String
+  attribute :public_key_path, kind_of: String
   # List of parameters to the private_key resource used for generation of the key
-  attribute :private_key_options, :kind_of => Hash
+  attribute :private_key_options, kind_of: Hash
 
-  # TODO what is the right default for this?
-  attribute :allow_overwrite, :kind_of => [TrueClass, FalseClass], :default => false
+  # TODO: what is the right default for this?
+  attribute :allow_overwrite, kind_of: [TrueClass, FalseClass], default: false
 
   # Proc that runs after the resource completes.  Called with (resource, private_key, public_key)
   def after(&block)
@@ -28,7 +28,7 @@ class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
   end
 
   # We are not interested in Chef's cloning behavior here.
-  def load_prior_resource(*args)
+  def load_prior_resource(*_args)
     Chef::Log.debug("Overloading #{resource_name}.load_prior_resource with NOOP")
   end
 end

data/lib/chef/resource/scaleway_volume.rb

@@ -1,7 +1,7 @@
-require 'chef/provisioning'
+require "chef/provisioning"
 
 class Chef::Resource::ScalewayVolume < Chef::Resource::LWRPBase
-  self.resource_name = 'scaleway_volume'
+  self.resource_name = "scaleway_volume"
 
   def initialize(*args)
     super
@@ -18,15 +18,15 @@ class Chef::Resource::ScalewayVolume < Chef::Resource::LWRPBase
   attribute :volume_options
 
   def add_volume_options(options)
-    if @volume_options
-      @volume_options = Cheffish::MergedConfig.new(options, @volume_options)
-    else
-      @volume_options = options
-    end
+    @volume_options = if @volume_options
+                        Cheffish::MergedConfig.new(options, @volume_options)
+                      else
+                        options
+                      end
   end
 
   # We are not interested in Chef's cloning behavior here.
-  def load_prior_resource(*args)
+  def load_prior_resource(*_args)
     Chef::Log.debug("Overloading #{resource_name}.load_prior_resource with NOOP")
   end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,9 @@
-$:.unshift File.expand_path('../../lib', __FILE__)
-$:.unshift File.expand_path('../support', __FILE__)
-require 'fog'
-require 'chef/provisioning'
-require 'chef/provisioning/fog_driver/driver'
-require 'simplecov'
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift File.expand_path("support", __dir__)
+require "fog"
+require "chef/provisioning"
+require "chef/provisioning/fog_driver/driver"
+require "simplecov"
 
 SimpleCov.start do
   # add_filter do |source_file|
@@ -20,7 +20,7 @@ RSpec.configure do |config|
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
-  config.order = 'random'
+  config.order = "random"
 end
 
 Fog.mock!

data/spec/support/chef/provisioning/fog_driver/providers/testdriver.rb

@@ -3,15 +3,15 @@ class Chef
     module FogDriver
       module Providers
         class TestDriver < FogDriver::Driver
-          Driver.register_provider_class('TestDriver', Chef::Provisioning::FogDriver::Providers::TestDriver)
+          Driver.register_provider_class("TestDriver", Chef::Provisioning::FogDriver::Providers::TestDriver)
 
           attr_reader :config
           def initialize(driver_url, config)
             super
           end
 
-          def self.compute_options_for(provider, id, config)
-            [config, 'test']
+          def self.compute_options_for(_provider, _id, config)
+            [config, "test"]
           end
         end
       end

data/spec/unit/chef/provisioning/fog_driver/driver_spec.rb

@@ -1,4 +1,4 @@
-require 'chef/provisioning/fog_driver/driver'
+require "chef/provisioning/fog_driver/driver"
 
 describe Chef::Provisioning::FogDriver::Driver do
   let(:driver) { Chef::Provisioning::FogDriver::Driver.new("fog:OpenStack", {}) }
@@ -8,102 +8,103 @@ describe Chef::Provisioning::FogDriver::Driver do
   end
 
   describe "#determine_remote_host" do
-    let(:machine_spec) { double("machine_spec", :reference => reference, :name => 'name') }
-    let(:server) { double("server", :private_ip_address => 'private', :public_ip_address => 'public', :ip_addresses => ['first_ip_address'])}
+    let(:machine_spec) { double("machine_spec", reference: reference, name: "name") }
+    let(:server) { double("server", private_ip_address: "private", public_ip_address: "public", ip_addresses: ["first_ip_address"]) }
 
     context "when 'use_private_ip_for_ssh' is specified in the machine_spec.reference" do
-      let(:reference) { { 'use_private_ip_for_ssh' => true } }
+      let(:reference) { { "use_private_ip_for_ssh" => true } }
       it "returns the private ip" do
-        expect(driver.determine_remote_host(machine_spec, server)).to eq('private')
-        expect(reference).to eq( {'transport_address_location' => :private_ip} )
+        expect(driver.determine_remote_host(machine_spec, server)).to eq("private")
+        expect(reference).to eq("transport_address_location" => :private_ip)
       end
     end
 
     context "when 'transport_address_location' is set to :private_ip" do
-      let(:reference) { { 'transport_address_location' => :private_ip } }
+      let(:reference) { { "transport_address_location" => :private_ip } }
       it "returns the private ip" do
-        expect(driver.determine_remote_host(machine_spec, server)).to eq('private')
+        expect(driver.determine_remote_host(machine_spec, server)).to eq("private")
       end
     end
 
     context "when 'transport_address_location' is set to :ip_addresses" do
-      let(:reference) { { 'transport_address_location' => :ip_addresses } }
+      let(:reference) { { "transport_address_location" => :ip_addresses } }
       it "returns the first ip_address from array" do
-        expect(driver.determine_remote_host(machine_spec, server)).to eq('first_ip_address')
+        expect(driver.determine_remote_host(machine_spec, server)).to eq("first_ip_address")
       end
     end
 
     context "when 'transport_address_location' is set to :public_ip" do
-      let(:reference) { { 'transport_address_location' => :public_ip } }
+      let(:reference) { { "transport_address_location" => :public_ip } }
       it "returns the public ip" do
-        expect(driver.determine_remote_host(machine_spec, server)).to eq('public')
+        expect(driver.determine_remote_host(machine_spec, server)).to eq("public")
       end
     end
 
     context "when machine_spec.reference does not specify the transport type" do
-      let(:reference) { Hash.new }
+      let(:reference) { {} }
 
       context "when the machine does not have a public_ip_address" do
-        let(:server) { double("server", :private_ip_address => 'private', :public_ip_address => nil, :ip_addresses => ['first_ip_address'])}
+        let(:server) { double("server", private_ip_address: "private", public_ip_address: nil, ip_addresses: ["first_ip_address"]) }
 
         it "returns the private ip" do
-          expect(driver.determine_remote_host(machine_spec, server)).to eq('private')
+          expect(driver.determine_remote_host(machine_spec, server)).to eq("private")
         end
       end
 
       context "when the machine has a public_ip_address" do
-        let(:server) { double("server", :private_ip_address => 'private', :public_ip_address => 'public', :ip_addresses => ['first_ip_address'])}
+        let(:server) { double("server", private_ip_address: "private", public_ip_address: "public", ip_addresses: ["first_ip_address"]) }
 
         it "returns the public ip" do
-          expect(driver.determine_remote_host(machine_spec, server)).to eq('public')
+          expect(driver.determine_remote_host(machine_spec, server)).to eq("public")
         end
       end
 
       context "when the machine does not have a public_ip_address or private_ip_address" do
-        let(:server) { double("server", :private_ip_address => nil, :public_ip_address => nil, :ip_addresses => ['first_ip_address'], :id => 'id')}
+        let(:server) { double("server", private_ip_address: nil, public_ip_address: nil, ip_addresses: ["first_ip_address"], id: "id") }
 
         it "raises an error" do
-          expect {driver.determine_remote_host(machine_spec, server)}.to raise_error("Server #{server.id} has no private or public IP address!")
+          expect { driver.determine_remote_host(machine_spec, server) }.to raise_error("Server #{server.id} has no private or public IP address!")
         end
       end
     end
   end
 
-  describe '#private_key_for' do
-    let(:machine_spec) { double('machine_spec', reference: {}, name: 'my_machine') }
-    let(:machine_options) { { bootstrap_options:  bootstrap_options } }
+  describe "#private_key_for" do
+    let(:machine_spec) { double("machine_spec", reference: {}, name: "my_machine") }
+    let(:machine_options) { { bootstrap_options: bootstrap_options } }
 
-    context 'when the machine has a key path in bootstrap options' do
-      let(:bootstrap_options) { { key_path: '/tmp/test_private_key_file' } }
+    context "when the machine has a key path in bootstrap options" do
+      let(:bootstrap_options) { { key_path: "/tmp/test_private_key_file" } }
 
-      it 'reads the key file' do
-        allow(IO).to receive(:read).and_return 'test_private_key'
-        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq 'test_private_key'
+      it "reads the key file" do
+        allow(IO).to receive(:read).and_return "test_private_key"
+        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq "test_private_key"
       end
     end
 
-    context 'when the machine has a key name in bootstrap options' do
-      let(:bootstrap_options) { { key_name: 'test_private_key_name' } }
+    context "when the machine has a key name in bootstrap options" do
+      let(:bootstrap_options) { { key_name: "test_private_key_name" } }
 
-      it 'calls get_private_key' do
-        expect(driver).to receive(:get_private_key).with('test_private_key_name').and_return 'test_private_key'
-        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq 'test_private_key'
+      it "calls get_private_key" do
+        expect(driver).to receive(:get_private_key).with("test_private_key_name").and_return "test_private_key"
+        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq "test_private_key"
       end
     end
 
-    context 'when the machine has no bootstrap options' do
-      it 'raises an error' do
+    context "when the machine has no bootstrap options" do
+      it "raises an error" do
         expect { driver.private_key_for(machine_spec, {}, nil) }
-          .to raise_error(RuntimeError, 'No key found to connect to my_machine ({}) : machine_options -> ({})!')
+          .to raise_error(RuntimeError, "No key found to connect to my_machine ({}) : machine_options -> ({})!")
       end
     end
 
-    context 'when the machine has no key path or key name bootstrap options' do
+    context "when the machine has no key path or key name bootstrap options" do
       let(:bootstrap_options) { {} }
 
-      it 'raises an error' do
+      it "raises an error" do
         expect { driver.private_key_for(machine_spec, machine_options, nil) }.to raise_error(
-          RuntimeError, 'No key found to connect to my_machine ({}) : machine_options -> ({:bootstrap_options=>{}})!')
+          RuntimeError, "No key found to connect to my_machine ({}) : machine_options -> ({:bootstrap_options=>{}})!"
+        )
       end
     end
   end