vagrant-proxmox 0.0.3 → 0.0.5

data/lib/vagrant-proxmox/errors.rb

@@ -26,14 +26,34 @@ module VagrantPlugins
 				error_key :no_vm_id_available
 			end
 
-			class VMCreationError < VagrantProxmoxError
-				error_key :vm_creation_error
+			class VMCreateError < VagrantProxmoxError
+				error_key :vm_create_error
+			end
+
+			class VMDestroyError < VagrantProxmoxError
+				error_key :vm_destroy_error
+			end
+
+			class VMStartError < VagrantProxmoxError
+				error_key :vm_start_error
+			end
+
+			class VMStopError < VagrantProxmoxError
+				error_key :vm_stop_error
+			end
+
+			class VMShutdownError < VagrantProxmoxError
+				error_key :vm_shutdown_error
 			end
 
 			class RsyncError < VagrantProxmoxError
 				error_key :rsync_error
 			end
 
+			class SSHError < VagrantProxmoxError
+				error_key :ssh_error
+			end
+
 		end
 	end
 end

data/lib/vagrant-proxmox/plugin.rb

@@ -1,17 +1,3 @@
-# Fix wrong header unescaping in RestClient library.
-module RestClient
-	class Request
-		def make_headers user_headers
-			unless @cookies.empty?
-				user_headers[:cookie] = @cookies.map { |(key, val)| "#{key.to_s}=#{val}" }.sort.join('; ')
-			end
-			headers = stringify_headers(default_headers).merge(stringify_headers(user_headers))
-			headers.merge!(@payload.headers) if @payload
-			headers
-		end
-	end
-end
-
 module VagrantPlugins
 	module Proxmox
 		class Plugin < Vagrant.plugin ('2')

data/lib/vagrant-proxmox/proxmox/connection.rb

@@ -0,0 +1,217 @@
+require 'vagrant-proxmox/proxmox/errors'
+require 'rest-client'
+require 'retryable'
+
+# Fix wrong header unescaping in RestClient library.
+module RestClient
+	class Request
+		def make_headers user_headers
+			unless @cookies.empty?
+				user_headers[:cookie] = @cookies.map { |(key, val)| "#{key.to_s}=#{val}" }.sort.join('; ')
+			end
+			headers = stringify_headers(default_headers).merge(stringify_headers(user_headers))
+			headers.merge!(@payload.headers) if @payload
+			headers
+		end
+	end
+end
+
+module VagrantPlugins
+	module Proxmox
+		class Connection
+
+			attr_reader :api_url
+			attr_reader :ticket
+			attr_reader :csrf_token
+			attr_accessor :vm_id_range
+			attr_accessor :task_timeout
+			attr_accessor :task_status_check_interval
+			attr_accessor :imgcopy_timeout
+
+			def initialize api_url, opts = {}
+				@api_url = api_url
+				@vm_id_range = opts[:vm_id_range] || (900..999)
+				@task_timeout = opts[:task_timeout] || 60
+				@task_status_check_interval = opts[:task_status_check_interval] || 2
+				@imgcopy_timeout = opts[:imgcopy_timeout] || 120
+			end
+
+			def login(username:, password:)
+				begin
+					response = post "/access/ticket", username: username, password: password
+					@ticket = response[:data][:ticket]
+					@csrf_token = response[:data][:CSRFPreventionToken]
+				rescue ApiError::ServerError
+					raise ApiError::InvalidCredentials
+				rescue => x
+					raise ApiError::ConnectionError, x.message
+				end
+			end
+
+			def get_node_list
+				nodelist = get '/nodes'
+				nodelist[:data].map { |n| n[:node] }
+			end
+
+			def get_vm_state vm_id
+				vm_info = get_vm_info vm_id
+				if vm_info
+					begin
+						response = get "/nodes/#{vm_info[:node]}/#{vm_info[:type]}/#{vm_id}/status/current"
+						states = {'running' => :running,
+											'stopped' => :stopped}
+						states[response[:data][:status]]
+					rescue ApiError::ServerError
+						:not_created
+					end
+				else
+					:not_created
+				end
+			end
+
+			def wait_for_completion task_response: task_response, timeout_message: timeout_message
+				task_upid = task_response[:data]
+				timeout = task_timeout
+				task_type = /UPID:.*?:.*?:.*?:.*?:(.*)?:.*?:.*?:/.match(task_upid)[1]
+				timeout = imgcopy_timeout if task_type == 'imgcopy'
+				begin
+					retryable(on: VagrantPlugins::Proxmox::ProxmoxTaskNotFinished,
+										tries: timeout / task_status_check_interval + 1,
+										sleep: task_status_check_interval) do
+						exit_status = get_task_exitstatus task_upid
+						exit_status.nil? ? raise(VagrantPlugins::Proxmox::ProxmoxTaskNotFinished) : exit_status
+					end
+				rescue VagrantPlugins::Proxmox::ProxmoxTaskNotFinished
+					raise VagrantPlugins::Proxmox::Errors::Timeout.new timeout_message
+				end
+			end
+
+			def delete_vm vm_id
+				vm_info = get_vm_info vm_id
+				response = delete "/nodes/#{vm_info[:node]}/#{vm_info[:type]}/#{vm_id}"
+				wait_for_completion task_response: response, timeout_message: 'vagrant_proxmox.errors.destroy_vm_timeout'
+			end
+
+			def create_vm(node:, vm_type:, params:)
+				response = post "/nodes/#{node}/#{vm_type}", params
+				wait_for_completion task_response: response, timeout_message: 'vagrant_proxmox.errors.create_vm_timeout'
+			end
+
+			def start_vm vm_id
+				vm_info = get_vm_info vm_id
+				response = post "/nodes/#{vm_info[:node]}/#{vm_info[:type]}/#{vm_id}/status/start", nil
+				wait_for_completion task_response: response, timeout_message: 'vagrant_proxmox.errors.start_vm_timeout'
+			end
+
+			def stop_vm vm_id
+				vm_info = get_vm_info vm_id
+				response = post "/nodes/#{vm_info[:node]}/#{vm_info[:type]}/#{vm_id}/status/stop", nil
+				wait_for_completion task_response: response, timeout_message: 'vagrant_proxmox.errors.stop_vm_timeout'
+			end
+
+			def shutdown_vm vm_id
+				vm_info = get_vm_info vm_id
+				response = post "/nodes/#{vm_info[:node]}/#{vm_info[:type]}/#{vm_id}/status/shutdown", nil
+				wait_for_completion task_response: response, timeout_message: 'vagrant_proxmox.errors.shutdown_vm_timeout'
+			end
+
+			def get_free_vm_id
+				response = get "/cluster/resources?type=vm"
+				allowed_vm_ids = vm_id_range.to_set
+				used_vm_ids = response[:data].map { |vm| vm[:vmid] }
+				free_vm_ids = (allowed_vm_ids - used_vm_ids).sort
+				free_vm_ids.empty? ? raise(VagrantPlugins::Proxmox::Errors::NoVmIdAvailable) : free_vm_ids.first
+			end
+
+			def upload_file(file, content_type:, node:, storage:)
+				unless is_file_in_storage? filename: file, node: node, storage: storage
+					res = post "/nodes/#{node}/storage/#{storage}/upload", content: content_type,
+										 filename: File.new(file, 'rb'), node: node, storage: storage
+					wait_for_completion task_response: res, timeout_message: 'vagrant_proxmox.errors.upload_timeout'
+				end
+			end
+
+			def list_storage_files(node:, storage:)
+				res = get "/nodes/#{node}/storage/#{storage}/content"
+				res[:data].map { |e| e[:volid] }
+			end
+
+			# This is called every time to retrieve the node and vm_type, hence on large
+			# installations this could be a huge amount of data. Probably an optimization
+			# with a buffer for the machine info could be considered.
+			private
+			def get_vm_info vm_id
+				response = get '/cluster/resources?type=vm'
+				response[:data]
+				.select { |m| m[:id] =~ /^[a-z]*\/#{vm_id}$/ }
+				.map {|m|	{id: vm_id, type: /^(.*)\/(.*)$/.match(m[:id])[1], node: m[:node]}}
+				.first
+			end
+
+			private
+			def get_task_exitstatus task_upid
+				node = /UPID:(.*?):/.match(task_upid)[1]
+				response = get "/nodes/#{node}/tasks/#{task_upid}/status"
+				response[:data][:exitstatus]
+			end
+
+			private
+			def get path
+				begin
+					response = RestClient.get "#{api_url}#{path}", {cookies: {PVEAuthCookie: ticket}}
+					JSON.parse response.to_s, symbolize_names: true
+				rescue RestClient::NotImplemented
+					raise ApiError::NotImplemented
+				rescue RestClient::InternalServerError
+					raise ApiError::ServerError
+				rescue RestClient::Unauthorized
+					raise ApiError::UnauthorizedError
+				rescue => x
+					raise ApiError::ConnectionError, x.message
+				end
+			end
+
+			private
+			def delete path
+				begin
+					response = RestClient.delete "#{api_url}#{path}", headers
+					JSON.parse response.to_s, symbolize_names: true
+				rescue RestClient::Unauthorized
+					raise ApiError::UnauthorizedError
+				rescue RestClient::NotImplemented
+					raise ApiError::NotImplemented
+				rescue RestClient::InternalServerError
+					raise ApiError::ServerError
+				rescue => x
+					raise ApiError::ConnectionError, x.message
+				end
+			end
+
+			private
+			def post path, params = {}
+				begin
+					response = RestClient.post "#{api_url}#{path}", params, headers
+					JSON.parse response.to_s, symbolize_names: true
+				rescue RestClient::Unauthorized
+					raise ApiError::UnauthorizedError
+				rescue RestClient::NotImplemented
+					raise ApiError::NotImplemented
+				rescue RestClient::InternalServerError
+					raise ApiError::ServerError
+				rescue => x
+					raise ApiError::ConnectionError, x.message
+				end
+			end
+
+			private
+			def headers
+				ticket.nil? ? {} : {CSRFPreventionToken: csrf_token, cookies: {PVEAuthCookie: ticket}}
+			end
+
+			private
+			def is_file_in_storage?(filename:, node:, storage:)
+				(list_storage_files node: node, storage: storage).find { |f| f =~ /#{File.basename filename}/ }
+			end
+		end
+	end
+end

data/lib/vagrant-proxmox/proxmox/errors.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+	module Proxmox
+
+		module ApiError
+
+			class InvalidCredentials < StandardError
+			end
+
+			class ConnectionError < StandardError
+			end
+
+			class NotImplemented < StandardError
+			end
+
+			class ServerError < StandardError
+			end
+
+			class UnauthorizedError < StandardError
+			end
+
+		end
+	end
+end

data/lib/vagrant-proxmox/version.rb

@@ -1,7 +1,7 @@
 module VagrantPlugins
 	module Proxmox
 
-		VERSION = '0.0.3'
+		VERSION = '0.0.5'
 
 	end
 end

data/locales/en.yml

@@ -15,7 +15,7 @@ en:
       destroy_vm_timeout: |-
         Destroying the vm on the proxmox server timed out.
       no_endpoint_specified: 'No endpoint specified.'
-      no_os_template_specified: 'No os_template specified.'
+      no_openvz_os_template_or_openvz_template_file_specified_for_type_openvz: 'No openvz_os_template or openvz_template_file specified for vm_type=:openvz'
       no_password_specified: 'No password specified.'
       no_user_name_specified: 'No user_name specified.'
       no_vm_id_available: |-
@@ -40,10 +40,37 @@ en:
       stop_vm_timeout: |-
         Stopping the vm on the proxmox server timed out.
       timeout: 'Timeout error'
-      vm_creation_error: |-
+      vm_create_error: |-
         Unable to create the virtual machine!
 
         Cause: %{proxmox_exit_status}
+      vm_destroy_error: |-
+        Unable to destroy the virtual machine!
+
+        Cause: %{proxmox_exit_status}
+      vm_start_error: |-
+        Unable to start the virtual machine!
+
+        Cause: %{proxmox_exit_status}
+      vm_stop_error: |-
+        Unable to stop the virtual machine!
+
+        Cause: %{proxmox_exit_status}
+      vm_shutdown_error: |-
+        Unable to shutdown the virtual machine!
+
+        Cause: %{proxmox_exit_status}
+      vm_not_running: |-
+        VM must be running to execute this command. Run `vagrant up`
+        to start the virtual machine.
+      file_not_found: "File for upload not found"
+      upload_server_error: "Error during upload"
+      ssh_error: Unable to establish an ssh connection to the virtual machine...
+      no_vm_type_specified: "No vm_type specified"
+      no_qemu_iso_or_qemu_iso_file_specified_for_vm_type_openvz: "No qemu_iso or qemu_iso_file specified for vm_type=:qemu"
+      no_qemu_iso_or_qemu_iso_file_specified_for_vm_type_qemu: "No qemu_iso or qemu_iso_file specified for vm_type=:qemu"
+      no_qemu_os_specified_for_vm_type_qemu: "No qemu_os specified for vm_type=:qemu"
+      no_qemu_disk_size_specified_for_vm_type_qemu: "No qemu_disk_size specified for vm_type=:qemu"
     not_created: 'The virtual machine is not created on the server!'
     rsync_folder: |-
           Rsyncing folder: %{hostpath} => %{guestpath}

data/spec/actions/cleanup_after_destroy_action_spec.rb

@@ -7,14 +7,14 @@ describe VagrantPlugins::Proxmox::Action::CleanupAfterDestroy do
 	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox)} }
 	let(:ui) { double('ui').as_null_object }
 
-	subject { described_class.new(-> (_) {}, environment) }
+	subject(:action) { described_class.new(-> (_) {}, environment) }
 
 	it_behaves_like 'a proxmox action call'
 
 	describe '#call', :need_box do
 		it 'should delete the directory `.vagrant/[:machine].name`' do
 			expect do
-				subject.call env
+				action.call env
 			end.to change{File.exists?(".vagrant/machines/#{env[:machine].name}/proxmox")}.to false
 		end
 	end

data/spec/actions/connect_proxmox_action_spec.rb

@@ -7,39 +7,56 @@ module VagrantPlugins::Proxmox
 
 		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
 		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox)} }
+		let(:api_url) { 'http://your.proxmox.machine/api' }
+		let(:username) { 'user' }
+		let(:password) { 'password' }
+		let(:connection) { env[:proxmox_connection] }
 
-		subject { described_class.new(-> (_) {}, environment) }
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
 		before { VagrantPlugins::Proxmox::Plugin.setup_i18n }
 
 		describe '#call' do
 
 			before do
-				allow(RestClient).to receive(:post).and_return({data: {ticket: 'valid_ticket', CSRFPreventionToken: 'valid_token'}}.to_json)
+				env[:machine].provider_config.endpoint = api_url
+				env[:machine].provider_config.user_name = username
+				env[:machine].provider_config.password = password
+				env[:machine].provider_config.vm_id_range = 500..555
+				env[:machine].provider_config.task_timeout = 123
+				env[:machine].provider_config.task_status_check_interval = 5
+				env[:machine].provider_config.imgcopy_timeout = 99
+				allow_any_instance_of(Connection).to receive :login
 			end
 
 			it_behaves_like 'a proxmox action call'
 
-			it 'should call the REST API access/ticket' do
-				RestClient.should_receive(:post).with('https://your.proxmox.server/api2/json/access/ticket', {username: 'vagrant', password: 'password'})
-				subject.call env
+			it 'should store a connection object in env[:proxmox_connection]' do
+				action.call env
+				expect(connection.api_url).to eq(api_url)
 			end
 
-			it 'should store the access ticket in env[:proxmox_ticket]' do
-				subject.call env
-				env[:proxmox_ticket].should == 'valid_ticket'
+			describe 'sets the connection configuration parameters' do
+				before { action.call env }
+				specify { expect(connection.vm_id_range).to eq(500..555) }
+				specify { expect(connection.task_timeout).to eq(123) }
+				specify { expect(connection.task_status_check_interval).to eq(5) }
+				specify { expect(connection.imgcopy_timeout).to eq(99) }
 			end
 
-			it 'should store the access ticket in env[:proxmox_csrf_prevention_token]' do
-				subject.call env
-				env[:proxmox_csrf_prevention_token].should == 'valid_token'
+			it 'should call the login function with credentials from configuration' do
+				expect_any_instance_of(Connection).to receive(:login).with username: username, password: password
+				action.call env
 			end
 
-			describe 'when the server communication fails' do
-				before { RestClient.stub(:post).and_return nil }
-				specify do
-					expect { subject.call env }.to raise_error Errors::CommunicationError
+			context 'when the server communication fails' do
+
+				before { allow_any_instance_of(Connection).to receive(:login).and_raise ApiError::InvalidCredentials }
+
+				it 'should raise an error' do
+					expect { action.call env }.to raise_error Errors::CommunicationError
 				end
+
 			end
 
 		end

data/spec/actions/create_vm_action_spec.rb

@@ -1,167 +1,192 @@
 require 'spec_helper'
 require 'actions/proxmox_action_shared'
 
-describe VagrantPlugins::Proxmox::Action::CreateVm do
+module VagrantPlugins::Proxmox
 
-	it_behaves_like VagrantPlugins::Proxmox::Action::ProxmoxAction
+	describe Action::CreateVm do
 
-	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
-	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
-							 proxmox_nodes: [{node: 'localhost'}],
-							 ui: double('ui').as_null_object} }
-	let(:app) { double('app').as_null_object }
-	let(:task_upid) { 'UPID:localhost:0000F6ED:00F8E25F:5268CD3B:vzcreate:100:vagrant@pve:' }
+		let(:vagrantfile) { 'dummy_box/Vagrantfile' }
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: vagrantfile }
+		let(:connection) { Connection.new 'https://your.proxmox.server/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
+								 proxmox_selected_node: 'localhost',
+								 ui: double('ui').as_null_object,
+								 proxmox_connection: connection} }
+		let(:app) { double('app').as_null_object }
+		let(:task_upid) { 'UPID:localhost:0000F6ED:00F8E25F:5268CD3B:vzcreate:100:vagrant@pve:' }
 
-	subject { described_class.new(app, environment) }
-
-	describe '#call' do
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
 		before do
-			allow(RestClient).to receive(:post).and_return({data: task_upid}.to_json)
-			allow(subject).to receive(:get_free_vm_id).with(env).and_return(100)
-			allow(subject).to receive(:wait_for_completion).and_return('OK')
+			allow(connection).to receive_messages :get_free_vm_id => 100
+			allow(connection).to receive_messages :create_vm => 'OK'
 		end
 
-		it_behaves_like 'a proxmox action call'
-		it_behaves_like 'a blocking proxmox action'
-
-		describe 'the post request send to create a new virtual machine' do
-
-			context 'with default config' do
-				specify do
-					RestClient.should_receive(:post).
-							with('https://your.proxmox.server/api2/json/nodes/localhost/openvz',
-									 {vmid: 100,
-										hostname: 'box',
-										ostemplate: 'local:vztmpl/template.tgz',
-										password: 'vagrant',
-										memory: 256,
-										description: 'vagrant_test_box'},
-									 anything).
-							and_return({data: task_upid}.to_json)
-					subject.call env
-				end
-			end
+		describe '#call' do
 
-			context 'with a specified hostname' do
-				before { env[:machine].config.vm.hostname = 'hostname' }
-				specify do
-					RestClient.should_receive(:post).
-							with('https://your.proxmox.server/api2/json/nodes/localhost/openvz',
-									 {vmid: 100,
-										hostname: 'hostname',
-										ostemplate: 'local:vztmpl/template.tgz',
-										password: 'vagrant',
-										memory: 256,
-										description: 'vagrant_test_box'},
-									 anything).
-							and_return({data: task_upid}.to_json)
-					subject.call env
-				end
-			end
+			it_behaves_like 'a proxmox action call'
 
-			context 'with a specified ip address' do
-				before { env[:machine].config.vm.stub(:networks) { [[:public_network, {ip: '127.0.0.1'}]] } }
-				specify do
-					RestClient.should_receive(:post).
-							with('https://your.proxmox.server/api2/json/nodes/localhost/openvz',
-									 {vmid: 100,
-										hostname: 'box',
-										ip_address: '127.0.0.1',
-										ostemplate: 'local:vztmpl/template.tgz',
-										password: 'vagrant',
-										memory: 256,
-										description: 'vagrant_test_box'},
-									 anything).
-							and_return({data: task_upid}.to_json)
-					subject.call env
-				end
-			end
+			describe 'the call to create a new virtual machine' do
 
-		end
+				context 'when the vm_type is :openvz' do
 
-		it 'should print a message to the user interface' do
-			env[:ui].should_receive(:info).with 'Creating the virtual machine...'
-			env[:ui].should_receive(:info).with 'Done!'
-			subject.call env
-		end
+					let(:vagrantfile) { 'dummy_box/Vagrantfile' }
+					before { allow(env[:machine].provider_config).to receive(:vm_type) { :openvz } }
 
-		it 'should store the node and vmid in env[:machine].id' do
-			subject.call env
-			env[:machine].id.should == 'localhost/100'
-		end
+					context 'with default config' do
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :openvz,
+																					 params: {vmid: 100,
+																										hostname: 'machine',
+																										ostemplate: 'local:vztmpl/template.tar.gz',
+																										password: 'vagrant',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
 
-		context 'when the proxmox server responds with an error to the create request' do
+					context 'with a specified hostname' do
+						before { env[:machine].config.vm.hostname = 'hostname' }
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :openvz,
+																					 params: {vmid: 100,
+																										hostname: 'hostname',
+																										ostemplate: 'local:vztmpl/template.tar.gz',
+																										password: 'vagrant',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
 
-			let(:error_exit_status) { ["can't lock container 100", "close (rename) atomic file '/etc/pve/nodes/localhost/openvz/100.conf' failed: File exists"] }
+					context 'with a specified ip address' do
+						before { allow(env[:machine].config.vm).to receive(:networks) { [[:public_network, {ip: '127.0.0.1'}]] } }
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :openvz,
+																					 params: {vmid: 100,
+																										hostname: 'machine',
+																										ip_address: '127.0.0.1',
+																										ostemplate: 'local:vztmpl/template.tar.gz',
+																										password: 'vagrant',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
+				end
 
-			before { subject.stub :sleep }
+				context 'when the vm_type is :qemu' do
+
+					let(:vagrantfile) { 'dummy_box/Vagrantfile_qemu' }
+					before { allow(env[:machine].provider_config).to receive(:vm_type) { :qemu } }
+
+					context 'with default config' do
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :qemu,
+																					 params: {vmid: 100,
+																										name: 'machine',
+																										ostype: :l26,
+																										ide2: 'local:iso/isofile.iso,media=cdrom',
+																										sata0: 'raid:30,format=qcow2',
+																										sockets: 1,
+																										cores: 1,
+																										net0: 'e1000,bridge=vmbr0',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
 
-			context 'when the proxmox server replies with an exit status describing the error' do
-				it 'should create a virtual machine with another vmid' do
-					expect(subject).to receive(:get_free_vm_id).with(env).twice.and_return(100, 101)
-					expect(subject).to receive(:wait_for_completion).twice.and_return(error_exit_status.sample, 'OK')
-					subject.call env
-					env[:machine].id.should == 'localhost/101'
-				end
-			end
+					context 'with a specified hostname' do
+						before { env[:machine].config.vm.hostname = 'hostname' }
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :qemu,
+																					 params: {vmid: 100,
+																										name: 'hostname',
+																										ostype: :l26,
+																										ide2: 'local:iso/isofile.iso,media=cdrom',
+																										sata0: 'raid:30,format=qcow2',
+																										sockets: 1,
+																										cores: 1,
+																										net0: 'e1000,bridge=vmbr0',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
 
-			context 'when the proxmox server replies with a "500 Internal Server Error"' do
-				it 'should create a virtual machine with another vmid' do
-					expect(subject).to receive(:get_free_vm_id).with(env).twice.and_return(100, 101)
-					expect(subject).to receive(:wait_for_completion).and_raise(RestClient::InternalServerError).once
-					expect(subject).to receive(:wait_for_completion).once.and_return('OK')
-					subject.call env
-					env[:machine].id.should == 'localhost/101'
+					context 'with predefined network settings' do
+						before { allow(env[:machine].config.vm).to receive(:networks) { [[:public_network, {ip: '127.0.0.1', macaddress: 'aa:bb:cc:dd:ee:ff'}]] } }
+						specify do
+							expect(connection).to receive(:create_vm).
+																			with(node: 'localhost',
+																					 vm_type: :qemu,
+																					 params: {vmid: 100,
+																										name: 'machine',
+																										ostype: :l26,
+																										ide2: 'local:iso/isofile.iso,media=cdrom',
+																										sata0: 'raid:30,format=qcow2',
+																										sockets: 1,
+																										cores: 1,
+																										net0: 'e1000=aa:bb:cc:dd:ee:ff,bridge=vmbr0',
+																										memory: 256,
+																										description: 'vagrant_test_machine'})
+							action.call env
+						end
+					end
 				end
 			end
 
-			context 'when the create requests fail continuously before the timeout deadline is reached' do
-				it 'should raise a VMCreationError' do
-					expect(subject).to receive(:get_free_vm_id).with(env).exactly(30).times.and_return(100)
-					expect(subject).to receive(:wait_for_completion).exactly(30).times.and_return(error_exit_status.sample)
-					expect { subject.send :call, env }.to raise_error VagrantPlugins::Proxmox::Errors::VMCreationError
-				end
+			it 'should print a message to the user interface' do
+				expect(env[:ui]).to receive(:info).with 'Creating the virtual machine...'
+				expect(env[:ui]).to receive(:info).with 'Done!'
+				action.call env
 			end
 
-		end
-
-	end
-
-	describe '#get_free_vm_id' do
+			it 'should store the node and vmid in env[:machine].id' do
+				action.call env
+				expect(env[:machine].id).to eq('localhost/100')
+			end
 
-		it 'should query the proxmox server for all qemu and openvz machines' do
-			RestClient.should_receive(:get).with('https://your.proxmox.server/api2/json/cluster/resources?type=vm', anything).and_return({data: []}.to_json)
-			subject.send(:get_free_vm_id, env)
-		end
+			it 'should get a free vm id from connection' do
+				expect(connection).to receive(:get_free_vm_id)
+				action.send :call, env
+			end
 
-		describe 'find the smallest unused vm_id in the configured range' do
+			context 'when the proxmox server responds with an error to the create request' do
 
-			before { env[:machine].provider_config.vm_id_range = 3..4 }
+				context 'when the proxmox server replies with an internal server error to the delete_vm call' do
+					it 'should raise a VMCreateError' do
+						allow(connection).to receive(:create_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMCreateError
+					end
+				end
 
-			context 'when free vm_ids are available' do
-				[
-						{used_vm_ids: {data: []}, smallest_free_in_range: 3},
-						{used_vm_ids: {data: [{vmid: 3}]}, smallest_free_in_range: 4},
-						{used_vm_ids: {data: [{vmid: 1}]}, smallest_free_in_range: 3},
-						{used_vm_ids: {data: [{vmid: 1}, {vmid: 3}]}, smallest_free_in_range: 4},
-				].each do |example|
-					it 'should return the smallest unused vm_id in the configured vm_id_range' do
-						allow(RestClient).to receive(:get).and_return(example[:used_vm_ids].to_json)
-						subject.send(:get_free_vm_id, env).should == example[:smallest_free_in_range]
+				context 'when the proxmox server replies with an internal server error to the task status request' do
+					it 'should raise a VMCreateError' do
+						allow(connection).to receive(:create_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMCreateError
 					end
 				end
-			end
 
-			context 'when no vm_ids are available' do
-				it 'should throw a no_vm_id_available error' do
-					allow(RestClient).to receive(:get).and_return({data: [{vmid: 1}, {vmid: 2}, {vmid: 3}, {vmid: 4}]}.to_json)
-					expect { subject.send :get_free_vm_id, env }.to raise_error VagrantPlugins::Proxmox::Errors::NoVmIdAvailable
+				context 'when the proxmox server does not reply the task status request with OK' do
+					it 'should raise a VMCreateError' do
+						allow(connection).to receive_messages :create_vm => 'create vm error'
+						expect { action.send :call, env }.to raise_error Errors::VMCreateError, /create vm error/
+					end
 				end
 			end
-
 		end
-
 	end
-
 end