vortex/src/provider_virtualbox.coffee

Virtual machine management toolkit.

fs = require 'fs'
url = require 'url'
async = require 'async'
logsmith = require 'logsmith'
path_extra = require 'path-extra'
vboxmanage = require 'vboxmanage'
portchecker = require 'portchecker'
shell_quote = require 'shell-quote'

# ---

download = require './download'

# ---

exports.Provider = class
	###
	This class exposes VirtualBox as a provider to Vortex.
	###
	
	constructor: (@manifest) ->
		###
		The provider accepts a manifest as a parameter by specification.
		###
		
	get_node: (node_name) ->
		###
		This method returns a node by looking up its name. It throws an error if the node is not found.
		###
		
		return @manifest.nodes[node_name] if @manifest.nodes? and @manifest.nodes[node_name]?
		throw new Error "node #{node_name} does not exist"
		
	extract_property: (property_name, node_name) ->
		###
		Extracts a property by looking into a node and upper layers of the manifest.
		###
		
		try
			node = @get_node node_name
		catch e
			node = null
			
		return node.virtualbox[property_name] if node?.virtualbox?[property_name]?
		return @manifest.virtualbox[property_name] if @manifest.virtualbox?[property_name]?
		return null
		
	#
	# Helper functions for extracting various properties.
	#
	extract_vm_id: (node_name) -> @extract_property 'vmId', node_name
	extract_vm_url: (node_name) -> @extract_property 'vmUrl', node_name
	extract_username: (node_name) -> @extract_property 'username', node_name
	extract_password: (node_name) -> @extract_property 'password', node_name
	extract_private_key: (node_name) -> @extract_property 'privateKey', node_name
	extract_passphrase: (node_name) -> @extract_property 'passphrase', node_name
	extract_ssh_port: (node_name) -> @extract_property 'sshPort', node_name
	#
	#
	#
	
	extract_namespace: (node_name) ->
		###
		Extracts a namespace by looking it up in the node itself and upper layers of the manifest
		###
		
		try
			node = @get_node node_name
		catch
			node = null
			
		return node.namespace if node?.namespace?
		return @manifest.namespace if @manifest.namespace?
		
	get_node_handle: (node_name) ->
		###
		Creates a VirtualBox friendlier name out of a node name. The method take into account the namespace.
		###
		
		namespace = @extract_namespace node_name
		
		return (if namespace then namespace + ':' else '') + node_name
		
	get_share_handle: (share_name) ->
		###
		Creates a VirtualBox friendlier name out of a share name.
		###
		
		return share_name.replace(/[^\w]+/, '_').replace(/_+/, '_')
		
	schedule_import: (vm_url, vm_id, callback) ->
		###
		Schedules import operation. The function will check if the vm_id exists before execution.
		###
		
		if not @import_queue?
			@import_queue = async.queue (task, callback) =>
				vboxmanage.machine.info task.vm_id, (err, info) =>
					return callback null if not err
					return @perform_import task.vm_url, task.vm_id, callback
					
		task =
			vm_url: vm_url
			vm_id: vm_id
			
		@import_queue.push task, callback
		
	perform_import: (vm_url, vm_id, callback) ->
		###
		Performs import operation.
		###
		
		logsmith.debug "import #{vm_url} into #{vm_id}"
		
		try
			spec = url.parse vm_url
		catch
			return callback new Error "cannot parse url #{vm_url}"
			
		return callback new Error "unsupported scheme for url #{vm_url}" if spec.protocol not in ['file:', 'http:', 'https:']
		
		if spec.protocol == 'file'
			if not spec.host
				local_path = spec.pathname
			else
				local_path = path_extra.resolve path_extra.dirname(@manifest.meta.location), path_extra.join(spec.host, spec.pathname)
				
			vboxmanage.machine.import local_path, vm_id, callback
		else
			local_name = (new Date()).getTime() + '-' + path_extra.basename(spec.pathname)
			local_path = path_extra.join path_extra.tempdir(), local_name
			
			download.get vm_url, local_path, (err) ->
				if err
					fs.unlink local_path, (err) ->
						logsmith.exception err if err
						
					return callback err
					
				vboxmanage.machine.import local_path, vm_id, (err) ->
					fs.unlink local_path, (err) ->
						logmisth.exception err if err
						
					return callback err if err
					return callback null
					
	bootstrap: (node_name, callback) ->
		###
		Provider-specific method for bootstrapping a node.
		###
		
		commands = [
			'sudo mkdir -p /etc/vortex/flags/'
			'sudo chmod a+rx /etc/vortex/flags/'
			
			'[ ! -f /etc/vortex/flags/network_ready ] && sudo ifconfig eth1 0.0.0.0 0.0.0.0'
			'[ ! -f /etc/vortex/flags/network_ready ] && sudo ifconfig eth2 0.0.0.0 0.0.0.0'
			'[ ! -f /etc/vortex/flags/network_ready ] && sudo dhclient -r eth1 eth2'
			'[ ! -f /etc/vortex/flags/network_ready ] && sudo dhclient eth1 eth2'
			'[ ! -f /etc/vortex/flags/network_ready ] && sudo touch /etc/vortex/flags/network_ready'
		]
		
		node_handle = @get_node_handle node_name
		
		#
		# First we verify the status of the node to check if the state is correct.
		#
		verify_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "node #{node_name} is not ready" if state != 'running'
				return callback null
				
		#
		# Next we check the exposed files and folders.
		#
		prepare_exposed = (callback) =>
			try
				node = @get_node node_name
			catch e
				node = null
				
			return callback null if not node?.expose?
			
			handle_exposure = (exposure, callback) =>
				source_path = path_extra.resolve path_extra.dirname(@manifest.meta.location), exposure.src
				
				fs.stat source_path, (err, stats) =>
					return callback new Error "cannot expose #{exposure.src} because it does not exist" if err
					
					if stats.isDirectory()
						share_handle = @get_share_handle exposure.dst
						
						commands.push shell_quote.quote ['sudo', 'mkdir', '-p', exposure.dst]
						commands.push shell_quote.quote ['sudo', 'mount.vboxsf', share_handle, exposure.dst, '-o', 'rw']
						
						return callback null
					else
						vboxmanage.instance.copy_from source_path, exposure.dst, callback
						
			async.eachSeries ({src: src, dst: dst} for src, dst of node.expose), handle_exposure, callback
			
		#
		# Finally we execute all commands that were scheduled.
		#
		run_commands = (callback) ->
			run_command = (command, callback) ->
				vboxmanage.instance.exec node_handle, 'vortex', 'vortex', '/bin/sh', '-c', command, (err, output) ->
					return callback err if err
					
					process.stdout.write output if logsmith.level in ['verbose', 'debug', 'silly']
					
					return callback null
					
			async.eachSeries commands, run_command, callback
			
		#
		# Action on the tasks.
		#
		async.waterfall [verify_status, prepare_exposed, run_commands], (err, state, address) ->
			return callback err if err
			return callback null
			
	status: (node_name, callback) ->
		###
		Provider-specific method for checking the status of a node.
		###
		
		node_handle = @get_node_handle node_name
		
		#
		# First we obtain basic info about the node.
		#
		obtain_machine_state = (callback) ->
			vboxmanage.machine.info node_handle, (err, info) ->
				return callback null, 'stopped' if err
				
				state = info.VMState.toLowerCase()
				
				switch state
					when 'saved' then state = 'paused'
					when 'paused' then state = 'paused'
					when 'running' then state = 'running'
					when 'starting' then state = 'booting'
					when 'powered off' then state = 'stopped'
					when 'guru meditation'then state = 'paused'
					
				return callback null, state
				
		#
		# Next we obtain the machine network address.
		#
		obtain_machine_address = (state, callback) ->
			vboxmanage.adaptors.list node_handle, (err, adaptors) ->
				return callback null, 'stopped', address if err
				
				try
					address = adaptors['Adaptor 1'].V4.IP
				catch e
					address = null
					state = 'booting'
					
				return callback null, state, address
				
		#
		# Action on the tasks.
		#
		async.waterfall [obtain_machine_state, obtain_machine_address], (err, state, address) ->
			return callback err if err
			return callback null, state, address
			
	boot: (node_name, callback) ->
		###
		Provider-specific method for booting a node.
		###
		
		vm_id = @extract_vm_id node_name
		
		return callback new Error 'no virtualbox "vmId" paramter specified for node' if not vm_id
		
		node_handle = @get_node_handle node_name
		
		#
		# First we verify the status of the node to check if the state is correct.
		#
		verify_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "node #{node_name} is already booting" if state == 'booting'
				return callback new Error "node #{node_name} is already running" if state == 'running'
				return callback new Error "node #{node_name} is halting" if state == 'halting'
				return callback new Error "node #{node_name} is paused" if state == 'paused'
				return callback null
				
		#
		# Next we attemp to remove the vm. Proceed if there is a failure.
		#
		attemp_to_remove_vm = (callback) ->
			vboxmanage.machine.remove node_handle, (err) ->
				logsmith.exception err if err
				
				return callback null
				
		#
		# Next we ensure that the vm exists by checking its id. If it doesn't exist download it from the net or fail misserably.
		#
		ensure_vm_id = (callback) =>
			vboxmanage.machine.info vm_id, (err, info) =>
				return callback null if not err
				
				vm_url = @extract_vm_url node_name
				
				return callback new Error 'no virtualbox "vmUrl" paramter specified for node' if not vm_url?
				
				@schedule_import vm_url, vm_id, callback
				
		#
		# Next we clone the vm into a new one that will be used for the purpose.
		#
		clone_vm = (callback) ->
			vboxmanage.machine.clone vm_id, node_handle, callback
			
		#
		# Next we ensure that there is basic networking going on inside VirtualBox.
		#
		ensure_networking = (callback) =>
			config =
				network:
					hostonly:
						vboxnet5:
							ip: '10.100.100.1'
							netmask: '255.255.255.0'
							
							dhcp:
								lower_ip: '10.100.100.101'
								upper_ip: '10.100.100.254'
								
					internal:
						vortex:
							ip: '10.200.200.1'
							netmask: '255.255.255.0'
							
							dhcp:
								lower_ip: '10.200.200.101'
								upper_ip: '10.200.200.254'
								
			vboxmanage.setup.system config, callback
			
		#
		# Next we setup the vm using the provided configuration.
		#
		setup_vm = (callback) =>
			config =
				network:
					adaptors: [
						{type: 'hostonly', network: 'vboxnet5'}
						{type: 'internal', network: 'vortex'}
						{type: 'nat'}
					]
				shares: {}
				
			try
				node = @get_node node_name
			catch e
				return callback e
				
			if node.expose?
				for src, dst of node.expose
					src = path_extra.resolve path_extra.dirname(@manifest.meta.location), src
					share_handle = @get_share_handle dst
					
					config.shares[share_handle] = src
					
			vboxmanage.setup.machine node_handle, config, callback
			
		#
		# Finally we start the vm.
		#
		start_vm = (callback) ->
			vboxmanage.instance.start node_handle, callback
			
		#
		# Action on the tasks.
		#
		async.waterfall [verify_status, attemp_to_remove_vm, ensure_vm_id, clone_vm, ensure_networking, setup_vm, start_vm], (err) =>
			return callback err if err
			return @status node_name, callback
			
	halt: (node_name, callback) ->
		###
		Provider-specific method for halting a node.
		###
		
		node_handle = @get_node_handle node_name
		
		#
		# First we verify the status of the node to check if the state is correct.
		#
		verify_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "#{node_name} is already halting" if state == 'halting'
				return callback new Error "#{node_name} is already stopped" if state == 'stopped'
				return callback null
				
		#
		# Next we attempt to shutdown the node. Proceed if there is a failure.
		#
		attempt_to_stop_vm = (callback) ->
			vboxmanage.instance.stop node_handle, (err) ->
				logsmith.exception err if err
				
				return callback null
				
		#
		# Finally we attempt to remove the node. Proceed if there is a failure.
		#
		attempt_to_remove_vm = (callback) ->
			vboxmanage.machine.remove node_handle, (err) ->
				logsmith.exception err if err
				
				return callback null
				
		#
		# Action on the tasks.
		#
		async.waterfall [verify_status, attempt_to_stop_vm, attempt_to_remove_vm], (err) =>
			return callback err if err
			return @status node_name, callback
			
	pause: (node_name, callback) ->
		###
		Provider-specific method for pausing a machine.
		###
		
		node_handle = @get_node_handle node_name
		
		#
		# First we verify the status of the node to check if the state is correct.
		#
		verify_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "#{node_name} is already paused" if state == 'paused'
				return callback new Error "#{node_name} is halting" if state == 'halting'
				return callback new Error "#{node_name} is stopped" if state == 'stopped'
				return callback null
				
		#
		# Finally we pause the vm. We use the save method.
		#
		pause_vm = (callback) ->
			vboxmanage.instance.save node_handle, callback
			
		#
		# Action on the tasks.
		#
		async.waterfall [verify_status, pause_vm], (err) =>
			return callback err if err
			return @status node_name, callback
			
	resume: (node_name, callback) ->
		###
		Provider-specific method for resuming a machine.
		###
		
		node_handle = @get_node_handle node_name
		
		#
		# First we verify the status of the node to check if the state is correct.
		#
		verify_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "#{node_name} is already booting" if state == 'booting'
				return callback new Error "#{node_name} is already running" if state == 'running'
				return callback new Error "#{node_name} is halting" if state == 'halting'
				return callback new Error "#{node_name} is stopped" if state == 'stopped'
				return callback null
				
		#
		# Then we attempt to start the vm if the state has been saved. Don't handle errors.
		#
		attempt_start_vm = (callback) ->
			vboxmanage.instance.start node_handle, (err) ->
				logsmith.exception err if err
				
				return callback null
				
		#
		# Finally we attempt to resume the vm. Don't handle errors.
		#
		attempt_resume_vm = (callback) ->
			vboxmanage.instance.resume node_handle, (err) ->
				logsmith.exception err if err
				
				return callback null
				
		#
		# Action on the tasks.
		#
		async.waterfall [verify_status, attempt_start_vm, attempt_resume_vm], (err) =>
			return callback err if err
			return @status node_name, callback
			
	shell_spec: (node_name, callback) ->
		###
		Provider-specific method for obtaining a shell spec from a node.
		###
		
		password = @extract_password node_name
		private_key = @extract_private_key node_name
		
		return callback new Error "no password or privateKey provided for node #{node_name}" if not password and not private_key
		
		ssh_port = @extract_ssh_port node_name
		
		if ssh_port
			ssh_port = parseInt ssh_port, 10
			
			return callback new Error "ssh port for node #{node_name} is incorrect" if isNaN ssh_port or ssh_port < 1
		else
			ssh_port = 22
			
		username = @extract_username node_name
		
		if not username
			username = 'vortex'
			
		passphrase = @extract_passphrase node_name
		
		#
		# First we obtain the node status by looking for the address and to check if the state is correct.
		#
		obtain_status = (callback) =>
			@status node_name, (err, state, address) ->
				return callback err if err
				return callback new Error "node #{node_name} is halting" if state == 'halting'
				return callback new Error "node #{node_name} is stopped" if state == 'stopped'
				return callback new Error "cannot find network address for node #{node_name}" if not address
				return callback null, address
				
		#
		# Next we continiusly check if the ssh port is open.
		#
		ensure_port = (address, callback) ->
			portchecker.isOpen ssh_port, address, (is_open) ->
				return callback null, address if is_open
				
				callee = arguments.callee
				milliseconds = 10000
				timeout = () -> portchecker.isOpen ssh_port, address, callee
				
				logsmith.debug "repeat check for ssh port open for node #{node_name} in #{milliseconds} milliseconds"
				
				setTimeout timeout, milliseconds
				
		#
		# Finally we build the spec and send it off.
		#
		build_spec = (address, callback) ->
			parts = []
			parts.push 'ssh://'
			parts.push encodeURIComponent username
			parts.push ':' + encodeURIComponent password if password
			parts.push '@'
			parts.push address
			parts.push ':' + ssh_port
			parts.push ';privateKey=' + encodeURIComponent private_key if private_key
			parts.push ';passphrase=' + encodeURIComponent passphrase if passphrase
			
			spec = parts.join ''
			spec_options =
				username: username
				password: password
				host: address
				port: ssh_port
				privateKey: private_key
				passphrase: passphrase
				
			return callback null, spec, spec_options
			
		#
		# Action on the tasks.
		#
		async.waterfall [obtain_status, ensure_port, build_spec], callback