nuri 0.5.1

data/modules/hpcloud/.gitignore

@@ -0,0 +1,2 @@
+*.pem
+*.bak

data/modules/hpcloud/README.md

@@ -0,0 +1,16 @@
+HPCloud module
+--------------
+
+Required Ruby Gems:
+- fog
+- json
+
+To use:
+- Copy your VM's SSH private key to filename 'hpcloud.pem'.
+- Edit file 'config.yml' by filling in
+	- access_key
+	- secret_key
+	- tenant_id
+  Those information can be found in your HPCloud account (menu API Keys of HPCloud console).
+- Set 'key_name' value.
+- Replace any necessary default values of HPCloud's attributes such as zone, image_id, flavour_id, etc.

data/modules/hpcloud/config.yml

@@ -0,0 +1,3 @@
+access_key: 
+secret_key: 
+tenant_id: 

data/modules/hpcloud/example.sfp

@@ -0,0 +1,18 @@
+include "../node/node.sfp"
+include "../hpcloud/hpcloud.sfp"
+include "../vm/vm.sfp"
+include "../apache/apache.sfp"
+
+proxy isa Node {
+	sfpAddress is "localhost"
+	hpcloud isa HPCloud {
+		key_name is "herrykey"
+	}
+}
+
+vm1 isa VM {
+	created = true
+	apache isa Apache {
+		running is true
+	}
+}

data/modules/hpcloud/hpcloud.rb

@@ -0,0 +1,241 @@
+require 'rubygems'
+require 'thread'
+require 'json'
+require 'fog'
+require 'yaml'
+require 'net/ssh'
+
+##############################
+#
+# Order of config file for credentials:
+# 1) <HOME_DIRECTORY>/.hpcloud
+# 2) <MODULE_DIRECTORY>/config.yml
+#
+#
+# Order of SSH key file
+# 1) <HOME_DIRECTORY>/.ssh/<KEY_PAIR_NAME>.pem
+# 2) <HOME_DIRECTORY>/.ssh/<KEY_PAIR_NAME>
+# 3) <MODULE_DIRECTORY>/<KEY_PAIR_NAME>.pem
+# 4) <MODULE_DIRECTORY>/<KEY_PAIR_NAME>
+# 5) <MODULE_DIRECTORY>/hpcloud.pem
+#
+##############################
+
+class Sfp::Module::HPCloud
+	include Sfp::Resource
+
+	### Sleep time in waiting a task to be finished - default: 5s
+	SleepTime = 5
+
+	### Number of tries in waiting a task to be finished - default: 120 (10 minutes)
+	Tries = 600 / SleepTime
+
+	def initialize
+		@conn = nil
+	end
+
+	def update_state
+		to_model
+
+		@state['running'] = running?
+		@state['vms'] = get_vms
+	end
+
+	##############################
+	#
+	# Action methods (see hpcloud.sfp and cloud.sfp)
+	#
+	##############################
+
+	def create_vm(params={})
+		return false if not self.running?
+
+		### determine VM's name
+		name = params['vm'].sub(/^\$\./, '')
+
+		log.info "Creating VM #{name} [WAIT]"
+
+		### check if VM is already exist
+		if get_vms.has_key?(name)
+			log.info "VM #{name} is already exist - Creating VM #{name} [OK]"
+			return true
+		end
+
+		### populate VM parameters
+		vm_model = resolve_model(params['vm'])
+		flavor = (vm_model['flavor'].to_s.length > 0 ? vm_model['flavor'].to_s : @model['vm_flavor'])
+		image = (vm_model['image'].to_s.length > 0 ? vm_model['image'].to_s : @model['vm_image'])
+		security_group = (vm_model['security_group'].to_s.length > 0 ? vm_model['security_group'].to_s : @model['vm_security_group'])
+		ssh_key_name = (vm_model['ssh_key_name'].to_s.length > 0 ? vm_model['ssh_key_name'].to_s : @model['vm_ssh_key_name'])
+		ssh_key_file = self.ssh_key_file(ssh_key_name)
+
+		### check SSH key file
+		if ssh_key_file.nil?
+			log.info "SSH key file '#{ssh_key_file}' is not available! #{ssh_key_name} - Creating VM #{name} [Failed]"
+			return false
+		end
+
+		### if not exist, then create the VM
+		created = false
+		begin
+			### submit create VM request
+			vm = @conn.servers.create({
+				:name => name,
+				:flavor_id => flavor,
+				:image_id => image,
+				:key_name => ssh_key_name,
+				:security_groups => [security_group],
+				:metadata => {'name' => name},
+			})
+
+			### set SSH config
+			vm.username = 'ubuntu'
+			vm.private_key_path = ssh_key_file
+
+			### wait until SSH is enabled
+			vm.wait_for { ready? and sshable? }
+
+			### install sfpagent
+			created = (vm.ready? and vm.sshable? and install_agent(vm, name, ssh_key_file))
+
+		rescue Exception => exp
+			log.info "#{exp}\n#{exp.backtrace.join("\n")}"
+		end
+
+		if not created
+			log.error "Creating VM #{name} [Failed]"
+
+			### delete if any error occured
+			delete_vm(params)
+		else
+			log.info "Creating VM #{name} [OK]"
+		end
+
+		created
+	end
+
+	def delete_vm(params={})
+		return false if not self.running?
+
+		### determine VM's name
+		name = params['vm'].sub(/^\$\./, '')
+
+		### check if VM is not exist
+		return true if !get_vms.has_key?(name)
+
+		### delete if VM with given name exists
+		@conn.servers.each { |s|
+			if s.name == name
+				@conn.delete_server(s.id)
+				break
+			end
+		}
+
+		### wait until the VM is completely deleted
+		tries = Tries
+		deleted = false
+		while not deleted and tries > 0
+			begin
+				deleted = !get_vms.has_key?(name)
+				break if deleted
+			rescue
+			end
+			log.info "VM:#{name} has been deleted."
+			tries -= 1
+			sleep SleepTime
+		end
+
+		deleted
+	end
+
+	##############################
+	#
+	# Helper methods
+	#
+	##############################
+
+	protected
+	def config_file
+		return Dir.home + '/.hpcloud' if ::File.exist?(Dir.home + '/.hpcloud')
+		::File.dirname(__FILE__) + '/config.yml'
+	end
+
+	def read_config
+		return {} if not ::File.exist?(config_file)
+		return YAML.load_file(config_file)
+	end
+
+	def ssh_key_file(key_name)
+		file = Dir.home + '/.ssh/' + key_name + '.pem'
+		return file if ::File.exist?(file)
+
+		file = Dir.home + '/.ssh/' + key_name
+		return file if ::File.exist?(file)
+
+		file = File.dirname(__FILE__) + '/' + key_name + '.pem'
+		return file if ::File.exist?(file)
+
+		file = File.dirname(__FILE__) + '/' + key_name
+		return file if ::File.exist?(file)
+
+		file = File.dirname(__FILE__) + '/hpcloud.pem'
+		return file if ::File.exist?(file)
+
+		nil
+	end
+
+	def running?
+		return true if not @conn.nil?
+		begin
+			config = self.read_config
+			@conn = Fog::Compute.new({
+				:provider => "HP",
+				:hp_tenant_id => config['tenant_id'],
+				:hp_access_key => config['access_key'],
+				:hp_secret_key => config['secret_key'],
+				:hp_auth_uri => @model['auth_uri'],
+				:hp_avl_zone => @model['zone']
+			})
+		rescue Exception => exp
+			log.error "#{exp}\n#{exp.backtrace.join("\n")}"
+			@conn = nil
+		end
+		return !!@conn
+	end
+
+	def get_vms
+		return {} if not running?
+		vms = {}
+		@conn.servers.each { |s|
+			vms[s.name] = {
+				'running' => s.ready?,
+				'ip' => s.public_ip_address
+			}
+		}
+		vms
+	end
+
+	def install_agent(vm, name, ssh_key_file=nil, ssh_user="ubuntu")
+		log.info "Installing agent in VM #{name} [WAIT]"
+
+		result = vm.ssh(['sudo apt-get update',
+		                 'sudo apt-get -y install sudo ruby1.9.1 ruby1.9.1-dev libz-dev libaugeas-ruby1.9.1 make gcc libxml2-dev libxslt-dev libreadline-dev',
+		                 'sudo gem install sfp sfpagent fog --no-ri --no-rdoc && sudo sfpagent -s'])
+
+		if result
+			Net::SSH.start(vm.public_ip_address, ssh_user, :keys => [ssh_key_file]) do |ssh|
+				log.info ssh.exec!('sudo sfpagent -s')
+				result = (ssh.exec!('sudo sfpagent -a') =~ /Agent is running/)
+			end
+		end
+
+		if !result
+			log.error "Installing agent in VM #{name} [Failed]"
+		else
+			log.info "Installing agent in VM #{name} [OK]"
+		end
+
+		result
+	end
+end
+

data/modules/hpcloud/hpcloud.sfp

@@ -0,0 +1,22 @@
+include "../cloud/cloud.sfp"
+
+schema HPCloud extends Cloud {
+	final description = "HPCloud US West Zone 2"
+	final auth_uri = "https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/"
+	final zone = "az-2.region-a.geo-1"
+
+	// default SSH username
+	final vm_username = "ubuntu"
+
+	// small instance
+	final vm_flavor = "100"
+
+	// Ubuntu 12.04 image
+	final vm_image = "67074"
+
+	// key pair which will be used to SSH to VM
+	final vm_ssh_key_name = "default"
+
+	// security group of the VM
+	final vm_security_group = "default"
+}

data/modules/hpcloud/test.sfp

@@ -0,0 +1,5 @@
+include "hpcloud.sfp"
+
+a isa HPCloud {
+	
+}

data/modules/install_module

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+DefaultPort=1314
+
+# verify the arguments
+if [[ "$1" == "" ]] || [[ "$2" == "" ]]; then
+	echo "Usage: install_module <address> [port] <module-name> ..."
+	exit 1
+fi
+
+# set the agent's address
+address=$1
+shift
+
+# set the agent's port number
+re='^[0-9]+$'
+if [[ $1 =~ $re ]]; then
+	port=$1
+	shift
+else
+	port=$DefaultPort
+fi
+
+# set a template command for sending the modules
+cmd="curl -s -i -X PUT $address:$port/modules"
+
+# setup directory for temporary files
+dir="/tmp/"$(date +%s%N)"$RANDOM"
+mkdir -p $dir
+
+# for every module in the arguments:
+# - archive the module's files to a temporary file
+# - update the sending command by adding the module
+# if the module is not exist then the program will
+# set missing_module flag and then break from the loop
+missing_module=0
+for module in "$@" ; do
+	if [[ -d "$module" ]]; then
+		tar cvzhf $dir/$module.tgz $module 1>/dev/null
+		cmd="$cmd -F $module=@$dir/$module.tgz"
+	else
+		echo "Module $module is not exist!"
+		missing_module=`expr $missing_module + 1`
+	fi
+done
+
+if [[ $missing_module == 0 ]]; then
+	# execute the sending command there is no missing module
+	result=`$cmd`
+	re='.*HTTP/1\.1 200 OK.*'
+	if ! [[ $result =~ $re ]]; then
+		missing_module=`expr $missing_module + 1`
+	fi
+fi
+
+# delete directory that holds temporary files
+rm -rf $dir
+
+if [[ $missing_module == 0 ]]; then
+	echo "status: ok"
+else
+	echo "status: failed"
+fi
+
+exit $missing_module

data/modules/machine/machine.rb

@@ -0,0 +1,95 @@
+class Sfp::Module::Machine
+	include Sfp::Resource
+
+	def update_state
+		to_model
+
+		@state['sfpAddress'] = @model['sfpAddress']
+		@state['sfpPort'] = @model['sfpPort']
+		@state['created'] = true
+
+		data = `dmidecode | grep -i product`.strip
+		if data.length <= 0
+			@state['hypervisor'] = 'N/A'
+		else
+			@state['hypervisor'] = data.split("\n")[0].split(":", 2)[1].to_s.strip.downcase
+		end
+
+		@state["cpus"] = (File.exist?('/proc/cpuinfo') ? `cat /proc/cpuinfo | grep processor | wc -l`.strip.to_i : -1)
+		@state['memory'] = (`which free`.strip != '' ? `free`.split("\n")[1].split(" ")[1] : -1)
+
+		@state['disk'] = get_disk_state
+	end
+
+	##############################
+	#
+	# Helper methods
+	#
+	##############################
+
+	protected
+
+	# generate the disks' state, try to automatically mount the disk to target directory
+	#
+	def get_disk_state
+		def generate_state
+			disk = {}
+			# get disks UUID
+			uuids = {}
+			`blkid`.each_line do |line|
+				line.strip!
+				next if line.length <= 0
+				device, info = line.split(':', 2)
+				info = info.split(' ')
+				uuids[device] = info[0].split('=', 2)[1].gsub(/"/, '')
+			end
+
+			# read fstab
+			`df -l`.each_line do |line|
+				line.strip!
+				next if line.length <= 0
+				data = line.split(' ')
+				if data[0][0..4] == '/dev/'
+					name = 'root'
+					if data[5] != '/'
+						model = (@model['disk'].is_a?(Hash) ? @model['disk'].select { |k,v| v['mount'] == data[5] if k[0] != '_' } : {})
+						name = (model.length > 0 ? model.keys.first : "uuid_#{uuids[data[0]]}")
+					end
+					disk[name] = {
+						'size' => (data[1].to_f / 1000.0).to_i,
+						'mount' => data[5],
+						'uuid' => uuids[data[0]]
+					}
+				end
+			end
+			disk
+		end
+
+		disk = generate_state
+
+		if @model['disk'].is_a?(Hash)
+			names = @model['disk'].keys.sort { |x,y| x <=> y }
+			device = "/dev/vdb"
+			# format unformatted disks, mount unmount disks
+			names.each { |name|
+				next if name[0] == '_' or disk.has_key?(name)
+				spec = @model['disk'][name]
+				status = `file -s #{device}`
+				if not (status =~ /ERROR/)
+					target = spec['mount'].to_s.strip
+					# format the disk if not yet formatted
+					system "mkfs.ext4 #{device}" if not (status =~ /.+ filesystem data/)
+					# create target directory if not exist
+					system "mkdir -p #{target}" if !File.exist? target
+					# add fstab record
+					system "sed -i '/^#{device}/d' /etc/fstab"
+					system "echo '#{device}   #{target}  ext4   defaults  0 0' >> /etc/fstab"
+				end
+				device = device.next
+			}
+			system 'mount -a'
+		end
+
+		generate_state
+	end
+end