nuri 0.5.3 → 0.5.4

data/modules/openstack/openstack.rb

@@ -0,0 +1,329 @@
+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::OpenStack
+	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
+
+		### get VM model from cache
+		vm_model = resolve_model(params['vm'])
+
+		### determine VM parameters
+		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)
+		ssh_user = (vm_model['ssh_user'].to_s.length > 0 ? vm_model['ssh_user'].to_s : @model['vm_ssh_user'].to_s)
+
+		### set network
+		networks = vm_model['networks'].keys.select! { |k| k[0] != '_' }
+		networks = Array(@model['vm_network']) if networks.length <= 0 and @model['vm_network'].strip.length > 0
+		nets = get_networks
+		networks.map! { |net| {'net_id' => nets[net]['id']} }
+
+		### 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
+		log.info "#{name}:VM - SSH user: #{ssh_user}, SSH key file: #{ssh_key_file}"
+
+		spec = {
+				:name => name,
+				:flavor_ref => flavor,
+				:image_ref => image,
+				:key_name => ssh_key_name,
+				:security_groups => [security_group],
+				:metadata => {'name' => name},
+			}
+		spec['nics'] = networks if networks.length > 0
+
+		log.info "#{name}:VM - #{spec.inspect}"
+
+		### if not exist, then create the VM
+		created = false
+		begin
+			### submit create VM request
+			vm = @conn.servers.create(spec)
+			log.info "#{name}:VM - spec has been submitted"
+
+			### set SSH config
+			vm.username = ssh_user # 'ubuntu'
+			vm.private_key_path = ssh_key_file
+
+			log.info "#{name}:VM - ready [Wait]"
+			### wait until SSH is enabled
+			vm.wait_for { ready? }
+			log.info "#{name}:VM - ready [OK]"
+
+			log.info "#{name}:VM - sshable [Wait]"
+			### wait until SSH is sshable
+			ip = nil
+			vm.wait_for {
+				#vm.sshable? ### this does not work (fog's bug?)
+				ip = vm.addresses['default'].first['addr'].to_s if
+					vm.addresses['default'].is_a?(Array) and vm.addresses['default'].length > 0
+				if ip.length > 0
+					port = 22
+					begin
+						Timeout::timeout(1) do
+						begin
+							s = TCPSocket.new(ip, port)
+							s.close
+							true
+							rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+								false
+							end
+						end
+					rescue Timeout::Error
+						false
+					end
+				else
+					false
+				end
+			}
+			log.info "#{name}:VM - sshable, ip: #{ip} [OK]"
+
+			### install sfpagent
+			created = install_agent(vm, name, ssh_key_file, ssh_user, ip)
+
+		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
+
+	def is_port_open?(ip, port)
+		begin
+			Timeout::timeout(1) do
+				begin
+					s = TCPSocket.new(ip, port)
+					s.close
+					true
+				rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+					false
+				end
+			end
+		rescue Timeout::Error
+			false
+		end
+	end
+
+	##############################
+	#
+	# Helper methods
+	#
+	##############################
+
+	protected
+	def config_file
+		return Dir.home + '/.openstack' if ::File.exist?(Dir.home + '/.openstack')
+		::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
+			credential = {
+				:provider           => :openstack,
+				:openstack_username => config['username'],
+				:openstack_api_key  => config['password'],
+				:openstack_auth_url => @model['auth_uri'],
+				:openstack_tenant   => config['tenant_id'],
+			}
+			@conn = Fog::Compute.new(credential)
+			@network = Fog::Network.new(credential)
+
+		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|
+			spec = {
+				'running' => s.ready?,
+				'ip' => s.public_ip_address.to_s,
+			}
+			spec['ip'] = s.addresses['default'].first['addr'] if
+				spec['ip'].length <= 0 and s.addresses['default'].is_a?(Array) and s.addresses['default'].length > 0
+			vms[s.name] = spec
+		}
+		vms
+	end
+
+	def get_networks
+		nets = {}
+		@network.networks.each do |net|
+			nets[net.name] = {
+				'status' => net.status.downcase,
+				'id' => net.id
+			}
+		end
+		nets
+	end	
+
+	def install_agent(vm, name, ssh_key_file=nil, ssh_user="ubuntu", ip=nil)
+		ip = vm.public_ip_address if ip.nil?
+
+		log.info "Installing agent on #{name}:VM, ip=#{ip} [Wait]"
+
+		begin
+			Net::SSH.start(ip, ssh_user, :keys => [ssh_key_file]) do |ssh|
+				if ssh.exec!('which sfpagent').strip.length <= 0
+					### install sfpagent
+					ssh.exec! 'apt-get update && ' +
+						'apt-get -y install sudo ruby1.9.1 ruby1.9.1-dev libz-dev libaugeas-ruby1.9.1 && ' +
+						'gem install sfp sfpagent net-ssh --no-ri --no-rdoc'
+					ssh.exec! 'sfpagent -t'
+				end
+				ssh.exec! 'sfpagent -s'
+				ssh.exec! "echo '#{path}' > /var/sfpagent/vm.in_cloud"
+
+				if ssh.exec!("hostname").strip != name
+					ssh.exec! "/bin/echo '#{name}' > /etc/hostname"
+					ssh.exec! "service hostname start; service hostname.sh start"
+					ssh.exec! "/bin/sed -i 's/#{name}.*/#{name}/g' /etc/hosts"
+					ssh.exec! "/bin/echo '#{ip} #{name}' >> /etc/hosts"
+				end
+			end
+			log.info "Installing agent on #{name}:VM, ip=#{ip} [OK]"
+			true
+		rescue Exception => exp
+			log.error "Installing agent on #{name}:VM, ip=#{ip} [Failed] - #{exp}\n#{exp.backtrace.join("\n")}"
+			false
+		end
+	end
+end
+

data/modules/openstack/openstack.sfp

@@ -0,0 +1,24 @@
+include "../cloud/cloud.sfp"
+
+schema OpenStack extends Cloud {
+	final description = "Openstack"
+	final auth_uri = "https://openstack.com/v2.0/tokens"
+
+	// default SSH username
+	final vm_ssh_user = "root"
+
+	// small instance
+	final vm_flavor = "2"
+
+	// default image
+	final vm_image = "67074"
+
+	// default key pair which will be used to SSH to VM
+	final vm_ssh_key_name = "default"
+
+	// default security group
+	final vm_security_group = "default"
+
+	// default network
+	final vm_network = "default"
+}

data/modules/os/os.rb

@@ -21,7 +21,7 @@ class Sfp::Module::OS
 		@state["type"] = `uname -s`.strip
 		@state["version"] = `uname -r`.strip
 		@state["arch"] = `uname -p`.strip
-		@state["platform"] = (File.exist?('/etc/issue') ? `cat /etc/issue`.strip : '')
+		@state["platform"] = RUBY_PLATFORM
 	end
 
 	def apply(p={})

data/modules/package2/apt-repo-list.sh

@@ -0,0 +1,15 @@
+#! /bin/sh
+# Script to get all the PPA installed on a system
+for APT in `find /etc/apt/ -name \*.list`; do
+    grep -Po "(?<=^deb\s).*?(?=#|$)" $APT | while read ENTRY ; do
+        HOST=`echo $ENTRY | cut -d/ -f3`
+        USER=`echo $ENTRY | cut -d/ -f4`
+        PPA=`echo $ENTRY | cut -d/ -f5`
+        #echo sudo apt-add-repository ppa:$USER/$PPA
+        if [ "ppa.launchpad.net" = "$HOST" ]; then
+            echo ppa:$USER/$PPA
+        else
+            echo ${ENTRY}
+        fi
+    done
+done

data/modules/package2/package2.rb

@@ -4,66 +4,236 @@ class Sfp::Module::Package2
 	include Sfp::Resource
 
 	def update_state
-		to_model
+		provider = @model['provider'].strip
+		if provider != self.provider
+			case provider
+			when 'apt'
+				self.extend(AptPackage)
+			when 'tar'
+				self.extend(TarPackage)
+			else
+				self.extend(GenericPackage)
+			end
+		end
+
+		get_state
+	end
 
-		@state['installed'] = installed?
-		@state['version'] = version?
+	def provider
+		nil
 	end
 
-	##############################
-	#
-	# Action methods (see Package2.sfp)
-	#
-	##############################
+	module GenericPackage
+		def provider
+			nil
+		end
 
-	@@lock = Mutex.new
+		def get_state
+		end
 
-	def installed?
-		name = @model['name'].to_s.strip
-		if name.length > 0
-			data = `/usr/bin/dpkg-query -W #{name} 2>/dev/null`.strip.chop.split(' ')
-			(data[0].to_s == name)
-		else
+		def install(p={})
 			false
 		end
-	end
 
-	def version?
-		name = @model['name'].to_s.strip
-		if name.length > 0
-			data = `/usr/bin/dpkg-query -W #{name} 2>/dev/null`.strip.chop.split(' ')
-			(data[0].to_s == name ? data[1] : "")
-		else
-			""
+		def uninstall(p={})
+			false
 		end
 	end
 
-	def install(p={})
-		name = @model['name'].to_s.strip
-		if name.length <= 0
-			false
-		elsif installed?
-			true
-		else
-			shell "dpkg --configure -a; apt-get -y --purge autoremove"
-			if shell "apt-get -y install #{name}"
-				true
+	module TarPackage
+		def provider
+			'tar'
+		end
+
+		def get_state
+			to_model
+			@state['installed'] = installed?
+			@state['version'] = version?
+			@state['home'] = (@state['installed'] ? @model['home'] : '')
+		end
+
+		def install(p={})
+			home = @model['home'].strip
+			return false if home.length <= 0
+	
+			# create home directory if not exist
+			shell "rm -rf #{home} && mkdir -p #{home}" if not ::File.directory?(home)
+			if not ::File.directory?(home)
+				log.info "Target directory #{home} cannot be created."
+				return false
+			end
+
+			file = url.split('/').last
+			dest = "#{home}/#{file}"
+			download(url, dest)
+	
+			# if downloaded file is not exist, then return false
+			if not ::File.exist?(dest)
+				log.error "Failed to download file from #{url}"
+				return false
+			end
+	
+			# extract tar file, and then delete it
+			shell "cd #{home} && tar xvzf #{file} && rm -f #{file}"
+	
+			basename = case ::File.extname(file)
+			when '.gz'
+				::File.basename(file, '.tar.gz')
+			when '.tgz'
+				::File.basename(file, '.tgz')
+			else
+				file
+			end
+	
+			shell "bash -c 'cd #{home}/#{basename} && shopt -s dotglob && mv -f * .. && cd .. && rm -rf #{basename}'"
+	
+			File.open("#{home}/#{signature}", 'w') { |f| f.write(Time.now.to_s) }
+
+			if not ::File.exist?(version_file)
+				File.open(version_file, 'w') { |f| f.write(@model['version']) }
+			end
+
+			installed?
+		end
+
+		def uninstall(p={})
+			shell "rm -rf #{@model['home']}" if ::File.exist?(@model['home'])
+			not installed?
+		end
+
+		def installed?
+			::File.file?("#{@model['home']}/#{signature}")
+		end
+
+		def version?
+			if ::File.file?(version_file)
+				File.read(version_file).strip
 			else
-				shell "dpkg --configure -a; apt-get -y update && apt-get -y install #{name}"
+				''
 			end
 		end
+
+		def version_file
+			"#{@model['home']}/VERSION"
+		end
+
+		def signature
+			".nuri.package"
+		end
+
+		def url
+			"#{@model['source']}/#{@model['name']}-#{@model['version']}.tar.gz"
+		end
 	end
 
-	def uninstall(package)
-		name = @model['name'].to_s.strip
-		if name.length <= 0
-			false
-		elsif not installed?
-			true
-		else
-			shell "dpkg --configure -a; apt-get -y --purge autoremove"
-			shell "apt-get -y --purge remove #{name} && apt-get -y --purge autoremove && apt-get -y --purge autoremove"
+	module AptPackage
+		def provider
+			'apt'
+		end
+
+		def get_state
+			to_model
+	
+			@state['installed'] = installed?
+			@state['version'] = version?
+		end
+	
+		##############################
+		#
+		# Action methods (see Package2.sfp)
+		#
+		##############################
+	
+		@@lock = Mutex.new
+	
+		def installed?(p={})
+			name = (p.has_key?(:name) ? p[:name] : @model['name'].to_s.strip)
+			if name.length > 0
+				data = `/usr/bin/dpkg-query -W #{name} 2>/dev/null`.strip.chop.split(' ')
+				(data[0].to_s == name)
+			else
+				false
+			end
 		end
+	
+		def version?(p={})
+			name = (p.has_key?(:name) ? p[:name] : @model['name'].to_s.strip)
+			if name.length > 0
+				data = `/usr/bin/dpkg-query -W #{name} 2>/dev/null`.strip.chop.split(' ')
+				(data[0].to_s == name ? data[1] : "")
+			else
+				""
+			end
+		end
+	
+		def install(p={})
+			return false if not repo_installed?
+	
+			name = @model['name'].to_s.strip
+			if name.length <= 0
+				false
+			elsif installed?
+				true
+			else
+				shell "dpkg --configure -a; apt-get -y --purge autoremove"
+				if not shell "apt-get -y install #{name}"
+					shell "dpkg --configure -a; apt-get -y update && apt-get -y install #{name}"
+				end
+				installed?
+			end
+		end
+	
+		def uninstall(package)
+			name = @model['name'].to_s.strip
+			if name.length <= 0
+				false
+			elsif not installed?
+				true
+			else
+				shell "dpkg --configure -a; apt-get -y --purge autoremove"
+				shell "apt-get -y --purge remove #{name} && apt-get -y --purge autoremove && apt-get -y --purge autoremove"
+				not installed?
+			end
+		end
+	
+		##############################
+		#
+		# Helper methods
+		#
+		##############################
+	
+		def repo_installed?
+			if @model['provider'] == 'apt'
+				case @model['source'].strip
+				when 'default', ''
+					true
+				else
+					apt_repo_installed?
+				end
+			else
+				true
+			end
+		end
+	
+		def apt_repo_installed?
+			type, _ = @model['source'].split(':')
+			if type == 'ppa'
+				repos = `/bin/bash #{File.dirname(__FILE__)}/apt-repo-list.sh`.strip.split("\n")
+				if not repos.include?(@model['source'])
+					log.info "Missing APT repository: #{@model['source']}"
+					if not installed?({:name => 'python-software-properties'})
+						shell "apt-get install -y python-software-properties"
+					end
+					log.info "Adding APT repository: #{@model['source']}"
+					shell "add-apt-repository #{model['source']} && apt-get update"
+				else
+					false
+				end
+			else
+				false
+			end
+		end
+
 	end
 
 =begin