clc-chef-metal-vsphere 0.3.0

data/lib/chef_metal_vsphere/vsphere_helpers.rb

@@ -0,0 +1,250 @@
+require 'rbvmomi'
+
+module ChefMetalVsphere
+  module Helpers
+
+    def vim(options = connect_options)
+      # reconnect on every call - connections may silently timeout during long operations (e.g. cloning)
+      RbVmomi::VIM.connect options
+    end
+
+    def find_vm(dc_name, vm_folder, vm_name)
+      folder = find_folder(dc_name, vm_folder) or raise("vSphere Folder not found [#{vm_folder}] for vm #{vm_name}")
+      vm     = folder.find(vm_name, RbVmomi::VIM::VirtualMachine)
+    end
+
+    def find_vm_by_id(uuid, connection = vim)
+      vm = connection.searchIndex.FindByUuid({:uuid => uuid, :vmSearch => true, :instanceUuid => true})
+    end
+
+    def vm_started?(vm, wait_on_port = 22)
+      return false if vm.nil?
+      state = vm.runtime.powerState
+      return false unless state == 'poweredOn'
+      return false unless port_ready?(vm, wait_on_port)
+      return true
+    end
+
+    def vm_stopped?(vm)
+      return true if vm.nil?
+      state = vm.runtime.powerState
+      return false unless state == 'poweredOff'
+      return false
+    end
+
+    def start_vm(vm, wait_on_port = 22)
+      state = vm.runtime.powerState
+      unless state == 'poweredOn'
+        vm.PowerOnVM_Task.wait_for_completion
+      end
+    end
+
+    def stop_vm(vm)
+      begin
+        vm.ShutdownGuest
+        sleep 2 until vm.runtime.powerState == 'poweredOff'
+      rescue
+        vm.PowerOffVM_Task.wait_for_completion
+      end
+    end
+
+    def port_ready?(vm, port)
+      vm_ip = vm.guest.ipAddress
+      return false if vm_ip.nil?
+
+      begin
+        tcp_socket = TCPSocket.new(vm_ip, port)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        false
+      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+    end
+
+    #folder could be like:  /Level1/Level2/folder_name
+    def find_folder(dc_name, folder_name)
+      #dc(dc_name).vmFolder.childEntity.grep(RbVmomi::VIM::Folder).find { |x| x.name == folder_name }
+      baseEntity = dc(dc_name).vmFolder
+      if folder_name && folder_name.length > 0
+        entityArray = folder_name.split('/')
+        entityArray.each do |entityArrItem|
+          if entityArrItem != ''
+            baseEntity = baseEntity.childEntity.grep(RbVmomi::VIM::Folder).find { |f| f.name == entityArrItem }
+          end
+        end
+      end
+      baseEntity
+    end
+
+    def dc(dc_name)
+      vim.serviceInstance.find_datacenter(dc_name) or raise("vSphere Datacenter not found [#{datacenter}]")
+    end
+
+    def do_vm_clone(dc_name, vm_template, vm_name, options)
+      datacenter = dc(dc_name)
+      pool = options[:resource_pool] ? find_pool(datacenter, options[:resource_pool]) : vm_template.resourcePool
+      rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(pool: pool)
+      raise ':resource_pool must be specified when cloning from a VM Template' if pool.nil?
+
+      unless options[:datastore].to_s.empty?
+        rspec.datastore = find_datastore(datacenter, options[:datastore])
+      end
+
+      clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+        location: rspec,
+        powerOn: false,
+        template: false
+      )
+
+      clone_spec.config = RbVmomi::VIM.VirtualMachineConfigSpec(:deviceChange => Array.new)
+
+      if options.has_key?(:customization_spec)
+        if(options[:customization_spec].is_a?(Hash))
+            cust_options = options[:customization_spec]
+            raise ArgumentError, "domain is required" unless cust_options.key?(:domain)
+            if cust_options.key?(:ipsettings)
+              raise ArgumentError, "ip and subnetMask is required for static ip" unless cust_options[:ipsettings].key?(:ip) and
+                                                                                        cust_options[:ipsettings].key?(:subnetMask)
+              cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(cust_options[:ipsettings])
+              cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp(:ipAddress => cust_options[:ipsettings][:ip])
+            end
+            cust_domain = cust_options[:domain]
+            cust_ip_settings ||= RbVmomi::VIM::CustomizationIPSettings.new(:ip => RbVmomi::VIM::CustomizationDhcpIpGenerator.new())
+            cust_ip_settings.dnsDomain = cust_domain
+            cust_global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
+            cust_global_ip_settings.dnsServerList = cust_ip_settings.dnsServerList
+            cust_global_ip_settings.dnsSuffixList = [cust_domain]
+            cust_hostname = RbVmomi::VIM::CustomizationFixedName.new(:name => cust_options[:hostname]) if cust_options.key?(:hostname)
+            cust_hostname ||= RbVmomi::VIM::CustomizationFixedName.new(:name => vm_name)
+            cust_hwclockutc = cust_options[:hw_clock_utc]
+            cust_timezone = cust_options[:time_zone]
+            cust_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
+              :domain => cust_domain,
+              :hostName => cust_hostname,
+              :hwClockUTC => cust_hwclockutc,
+              :timeZone => cust_timezone)
+            cust_adapter_mapping = [RbVmomi::VIM::CustomizationAdapterMapping.new(:adapter => cust_ip_settings)]
+            cust_spec = RbVmomi::VIM::CustomizationSpec.new(
+              :identity => cust_prep,
+              :globalIPSettings => cust_global_ip_settings,
+              :nicSettingMap => cust_adapter_mapping)
+        else
+          cust_spec = find_customization_spec(options[:customization_spec])
+        end
+        clone_spec.customization = cust_spec
+      end
+
+      unless options[:annotation].to_s.nil?
+        clone_spec.config.annotation = options[:annotation]
+      end
+
+      unless options[:num_cpus].to_s.nil?
+        clone_spec.config.numCPUs = options[:num_cpus]
+      end
+
+      unless options[:memory_mb].to_s.nil?
+        clone_spec.config.memoryMB = options[:memory_mb]
+      end
+
+      unless options[:network_name].to_s.nil?
+        network = find_network(datacenter, options[:network_name])
+        card = vm_template.config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).first
+        begin
+          switch_port = RbVmomi::VIM.DistributedVirtualSwitchPortConnection(:switchUuid => network.config.distributedVirtualSwitch.uuid, :portgroupKey => network.key)
+          card.backing.port = switch_port
+        rescue
+          # not connected to a distibuted switch?
+          card.backing.deviceName = options[:network_name]
+        end
+        dev_spec = RbVmomi::VIM.VirtualDeviceConfigSpec(:device => card, :operation => "edit")
+        clone_spec.config.deviceChange.push dev_spec
+      end
+
+      vm_template.CloneVM_Task(
+        name: vm_name,
+        folder: find_folder(dc_name, options[:vm_folder]),
+        spec: clone_spec
+      ).wait_for_completion
+
+    vm = find_vm(dc_name, options[:vm_folder], vm_name)
+
+    unless options[:additional_disk_size_gb].to_s.nil?
+      if options[:datastore].to_s.empty? 
+        raise ":datastore must be specified when adding a disk to a cloned vm"
+      end
+      idx = vm.disks.count
+      task = vm.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(:deviceChange =>[RbVmomi::VIM::VirtualDeviceConfigSpec(
+            :operation     => :add,
+            :fileOperation => :create,
+            :device        => RbVmomi::VIM.VirtualDisk(
+              :key           => idx,
+              :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
+                :fileName        => "[#{options[:datastore]}]",
+                :diskMode        => 'persistent',
+                :thinProvisioned => true
+              ),
+              :capacityInKB  => options[:additional_disk_size_gb] * 1024 * 1024,
+              :controllerKey => 1000,
+              :unitNumber    => idx
+            )
+      )]))
+      task.wait_for_completion
+    end
+
+    vm
+    end
+
+    def find_network(dc, network_name)
+      baseEntity = dc.network
+      baseEntity.find { |f| f.name == network_name } or raise "no such network #{network_name}"
+    end
+
+    def find_datastore(dc, datastore_name)
+        baseEntity = dc.datastore
+        baseEntity.find { |f| f.info.name == datastore_name } or raise "no such datastore #{datastore_name}"    
+    end
+
+    def find_pool(dc, pool_name)
+      baseEntity = dc.hostFolder
+      entityArray = pool_name.split('/')
+      entityArray.each do |entityArrItem|
+        if entityArrItem != ''
+          if baseEntity.is_a? RbVmomi::VIM::Folder
+            baseEntity = baseEntity.childEntity.find { |f| f.name == entityArrItem } or nil
+          elsif baseEntity.is_a? RbVmomi::VIM::ClusterComputeResource or baseEntity.is_a? RbVmomi::VIM::ComputeResource
+            baseEntity = baseEntity.resourcePool.resourcePool.find { |f| f.name == entityArrItem } or nil
+          elsif baseEntity.is_a? RbVmomi::VIM::ResourcePool
+            baseEntity = baseEntity.resourcePool.find { |f| f.name == entityArrItem } or nil
+          else
+            baseEntity = nil
+          end
+        end
+      end
+
+      raise "vSphere ResourcePool not found [#{pool_name}]" if baseEntity.nil?
+
+      baseEntity = baseEntity.resourcePool if not baseEntity.is_a?(RbVmomi::VIM::ResourcePool) and baseEntity.respond_to?(:resourcePool)
+      baseEntity
+    end
+
+    def find_customization_spec(customization_spec)
+      csm = vim.serviceContent.customizationSpecManager
+      csi = csm.GetCustomizationSpec(:name => customization_spec)
+      spec = csi.spec
+      raise "Customization Spec not found [#{customization_spec}]" if spec.nil?
+      spec
+    end
+  end
+end

data/lib/chef_metal_vsphere/vsphere_url.rb

@@ -0,0 +1,31 @@
+require 'uri'
+
+module URI
+	class VsphereUrl < Generic
+		DEFAULT_PORT = 443
+		DEFAULT_PATH = '/sdk'
+
+		def self.from_config(options)
+			URI("vsphere://#{options[:host]}:#{options[:port]}#{options[:path]}?use_ssl=#{options[:use_ssl]}&insecure=#{options[:insecure]}")
+		end
+
+		def use_ssl
+			if query
+				ssl_query = query.split('&').each.select{|q| q.start_with?('use_ssl=')}.first
+				ssl_query == 'use_ssl=true'
+			else
+				true
+			end
+		end
+
+		def insecure
+			if query
+				insecure_query = query.split('&').each.select{|q| q.start_with?('insecure=')}.first
+				insecure_query == 'insecure=true'
+			else
+				false
+			end
+		end
+	end
+	@@schemes['VSPHERE'] = VsphereUrl
+end

data/spec/integration_tests/.gitignore

@@ -0,0 +1 @@
+config.rb

data/spec/integration_tests/vsphere_driver_spec.rb

@@ -0,0 +1,123 @@
+require 'chef_metal_vsphere/vsphere_driver'
+#require 'chef_metal_vsphere/ubuntu_patch'
+require 'chef_metal/chef_machine_spec'
+
+	# A file named config.rb in the same directory as this spec file 
+	# must exist containing the driver options to use for the test.
+	# Here is an example:
+	# {
+	#   :driver_options => { 
+	#   	:host => '213.45.67.88',
+	#   	:user => 'vmapi',
+	#   	:password => 'SuperSecureP@ssw0rd',
+	#   	:insecure => true
+	#   },
+	#   :machine_options => { 
+	# 		:start_timeout => 600, 
+ #            :create_timeout => 600, 	  	
+ #            :bootstrap_options => {
+	#   		:datacenter => 'QA1',
+	#   		:template_name => 'UBUNTU-12-64-TEMPLATE',
+	#   		:vm_folder => 'DLAB',
+	#   		:num_cpus => 2,
+	#   		:network_name => 'vlan152_172.21.152',
+	#   		:memory_mb => 4096,
+	#   		:resource_pool => 'CLSTR02/DLAB',
+	# 	  	:ssh => {
+	# 	  		:user => 'root',
+	# 	  		:password => 'SuperSecureP@ssw0rd',
+	# 	  		:paranoid => false,
+	# 	  		:port => 22
+	# 	  	},
+	# 	  	:convergence_options => {}
+	#   	}
+	#   }
+	# }
+
+describe "vsphere_driver" do
+    include ChefMetalVsphere::Helpers
+
+	before :all do
+		@vm_name = "cmvd-test-#{SecureRandom.hex}"
+		@metal_config = eval File.read(File.expand_path('../config.rb', __FILE__))
+		Cheffish.honor_local_mode do
+			chef_server = Cheffish.default_chef_server(@metal_config)
+			puts "chef server:#{chef_server}"
+			@machine_spec = ChefMetal::ChefMachineSpec.new({'name' => @vm_name}, chef_server)
+			@driver = ChefMetal.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
+			action_handler = ChefMetal::ActionHandler.new
+			@driver.allocate_machine(action_handler, @machine_spec, @metal_config[:machine_options])
+			@metal_config[:machine_options][:convergence_options] = {:chef_server => chef_server}
+			@driver.ready_machine(action_handler, @machine_spec, @metal_config[:machine_options])
+			@server_id = @machine_spec.location['server_id']
+			@connection = vim(@metal_config[:driver_options])
+			@vm = find_vm_by_id(@server_id, @connection)
+		end
+	end
+
+
+    context 'when allocating a machine' do
+
+		it "adds machine to the correct folder" do
+			expect(@vm.parent.name).to eq(@metal_config[:machine_options][:bootstrap_options][:vm_folder])
+		end
+		it "has a matching id with the machine_spec" do
+			expect(@vm.config.instanceUuid).to eq(@machine_spec.location['server_id'])
+		end
+		it "has the correct name" do
+			expect(@vm.config.name).to eq(@vm_name)
+		end
+		it "has the correct number of CPUs" do
+			expect(@vm.config.hardware.numCPU).to eq(@metal_config[:machine_options][:bootstrap_options][:num_cpus])
+		end
+		it "has the correct amount of memory" do
+			expect(@vm.config.hardware.memoryMB).to eq(@metal_config[:machine_options][:bootstrap_options][:memory_mb])
+		end
+		it "is on the correct network" do
+			expect(@vm.network[0].name).to eq(@metal_config[:machine_options][:bootstrap_options][:network_name])
+		end
+		it "is on the correct datastore" do
+			expect(@vm.datastore[0].name).to eq(@metal_config[:machine_options][:bootstrap_options][:datastore])
+		end
+		it "is in the correct resource pool" do
+			expect(@vm.resourcePool.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[1])
+		end
+		it "is in the correct cluster" do
+			expect(@vm.resourcePool.owner.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[0])
+		end
+		it "is in the correct datacenter" do
+			expect(@connection.serviceInstance.find_datacenter(@metal_config[:machine_options][:bootstrap_options][:datacenter]).find_vm("#{@vm.parent.name}/#{@vm_name}")).not_to eq(nil)
+		end
+		it "has an added disk of the correct size" do
+			disk_count = @vm.disks.count
+			expect(@vm.disks[disk_count-1].capacityInKB).to eq(@metal_config[:machine_options][:bootstrap_options][:additional_disk_size_gb] * 1024 * 1024)
+		end
+		it "has the correct IP address" do
+	      if @vm.guest.toolsRunningStatus != "guestToolsRunning"
+	      	now = Time.now.utc
+	        until (Time.now.utc - now) > 30 || (@vm.guest.toolsRunningStatus == "guestToolsRunning" && !@vm.guest.ipAddress.nil? && @vm.guest.ipAddress.length > 0) do
+	          print "."
+	          sleep 5
+	        end
+	      end
+			expect(@vm.guest.ipAddress).to eq(@metal_config[:machine_options][:bootstrap_options][:customization_spec][:ipsettings][:ip])
+		end
+    end
+
+	context "destroy_machine" do
+
+		it "removes the machine" do
+			Cheffish.honor_local_mode do
+				chef_server = Cheffish.default_chef_server(@metal_config)
+				driver = ChefMetal.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
+				action_handler = ChefMetal::ActionHandler.new
+				machine_spec = ChefMetal::ChefMachineSpec.new({'name' => @vm_name}, chef_server)
+				machine_spec.location = { 'driver_url' => driver.driver_url,
+										  'server_id' => @server_id}
+				driver.destroy_machine(action_handler, machine_spec, @metal_config[:machine_options])
+			end
+			vm = find_vm_by_id(@server_id, @connection)
+			expect(vm).to eq(nil)
+		end
+	end
+end

data/spec/unit_tests/VsphereDriver_spec.rb

@@ -0,0 +1,206 @@
+require 'chef_metal_vsphere/vsphere_driver'
+
+describe "canonicalize_url" do
+
+	context "when config does not include the properties included in the url" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>'
+		  },
+		  :machine_options => { 
+		  	:ssh => {
+		  		:password => '<password>',
+		  		:paranoid => false
+		  	},
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB'
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefMetalVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
+		}
+
+		it "populates the config with correct host from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:host]).to eq('3.3.3.3')
+		end
+		it "populates the config with correct port from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:port]).to eq(999)
+		end
+		it "populates the config with correct path from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:path]).to eq('/crazyapi')
+		end
+		it "populates the config with correct use_ssl setting from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(false)
+		end
+		it "populates the config with correct insecure setting from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(true)
+		end
+	end
+
+	context "when config keys are stringified" do
+		metal_config = {
+		  'driver_options' => { 
+		  	'user' => 'vmapi',
+		  	'password' => '<password>'
+		  },
+		  'machine_options' => { 
+		  	'ssh' => {
+		  		'password' => '<password>'
+		  	},
+		  	'bootstrap_options' => {
+		  		'datacenter' => 'QA1'
+		  	}
+		  }
+		 }
+
+		let(:results) {
+			ChefMetalVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
+		}
+
+		it "will symbolize user" do
+			expect(results[1][:driver_options][:connect_options][:user]).to eq('vmapi')
+		end
+		it "will symbolize password" do
+			expect(results[1][:driver_options][:connect_options][:password]).to eq('<password>')
+		end
+		it "will symbolize ssh password" do
+			expect(results[1][:machine_options][:ssh][:password]).to eq('<password>')
+		end
+		it "will symbolize ssh bootstrap options" do
+			expect(results[1][:machine_options][:bootstrap_options][:datacenter]).to eq('QA1')
+		end
+	end
+
+	context "when no url is in the config" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  	:host => '4.4.4.4',
+		  	:port => 888,
+		  	:path => '/yoda',
+		  	:use_ssl => 'false',
+		  	:insecure => 'true'
+		  },
+		  :machine_options => { 
+		  	:ssh => {
+		  		:password => '<password>',
+		  		:paranoid => false
+		  	},
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB'
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefMetalVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
+		}
+
+		it "creates the correct driver url from config settings" do
+			expect(results[0]).to eq('vsphere://4.4.4.4:888/yoda?use_ssl=false&insecure=true')
+		end
+	end
+
+	context "when no url is in the config and config is missing defaulted values" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  	:host => '4.4.4.4'
+		  },
+		  :machine_options => { 
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB',
+			  	:ssh => {
+			  		:password => '<password>',
+			  		:paranoid => false
+			  	}
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefMetalVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
+		}
+
+		it "creates the correct driver url from default settings" do
+			expect(results[0]).to eq('vsphere://4.4.4.4/sdk?use_ssl=true&insecure=false')
+		end
+		it "populates the config with correct port from default settings" do
+			expect(results[1][:driver_options][:connect_options][:port]).to eq(443)
+		end
+		it "populates the config with correct path from default settings" do
+			expect(results[1][:driver_options][:connect_options][:path]).to eq('/sdk')
+		end
+		it "populates the config with correct use_ssl setting from default settings" do
+			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(true)
+		end
+		it "populates the config with correct insecure setting from default settings" do
+			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(false)
+		end
+		it "populates the config with correct ssh port from default settings" do
+			expect(results[1][:machine_options][:bootstrap_options][:ssh][:port]).to eq(22)
+		end
+	end
+
+	context "when missing host" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end
+
+	context "when missing user" do
+		metal_config = {
+		  :driver_options => { 
+		  	:host => 'host',
+		  	:password => '<password>',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end
+
+	context "when missing password" do
+		metal_config = {
+		  :driver_options => { 
+		  	:host => 'host',
+		  	:user => 'user',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end	
+end