nuri 0.5.2 → 0.5.3

data/lib/nuri/orchestrator.rb

@@ -3,29 +3,31 @@ require 'thread'
 module Nuri::Orchestrator
 	include Nuri::Helper
 
-	def execute_plan(p={})
-		raise Exception, "Plan file is not exist!" if not File.exist?(p[:execute].to_s) and !p[:plan]
-		raise Exception, "Plan is not exist (parameter :plan must be given)!" if !p[:plan]
+	def execute_plan(options={})
+		raise Exception, "Plan file is not exist!" if not File.exist?(options[:execute].to_s) and !options[:plan]
+		raise Exception, "Plan is not exist (parameter :plan must be given)!" if !options[:plan]
 
 		push_agents_list
 
 		success = false
 		benchmark = Benchmark.measure {
-			plan = (p[:plan] ? p[:plan] : JSON[File.read(p[:execute])])
-			raise Exception, "Invalid plan!" if plan['workflow'].nil?
+			plan = (options[:plan] ? options[:plan] : JSON[File.read(options[:execute])])
+			raise Exception, "No plan." if plan['workflow'].nil?
 			if plan.is_a?(Hash) and plan['type'] == 'sequential'
-				success = execute_sequential_plan(plan, p)
+				success = execute_sequential_plan(plan, options)
 			elsif plan.is_a?(Hash) and plan['type'] == 'parallel'
-				success = execute_parallel_plan(plan, p)
+				success = execute_parallel_plan(plan, options)
+			else
+				raise Exception, "Invalid plan."
 			end
 		}
-		puts "Execution time (s): #{benchmark}"
+		puts "Execution " + format_benchmark(benchmark)
 
 		success
 	end
 
 	protected
-	def send_action_data(action, address, port)
+	def send_action_data(action, address, port, options={})
 		action['parameters'].each do |name,value|
 			next if !value.is_a?(String) or !value.isref or value.split('.').length > 2
 			_, target_name = value.split('.', 2)
@@ -38,7 +40,8 @@ module Nuri::Orchestrator
 			rescue
 			end
 			if code != '200'
-				$stderr.puts "Sending action data of #{value} to #{address}:#{port} [Failed]".red
+				$stderr.print "Sending action data of #{value} to #{address}:#{port} "
+				$stderr.puts (options[:color] ? "[Failed]".red : "[Failed]")
 				return false
 			end
 		end
@@ -46,7 +49,7 @@ module Nuri::Orchestrator
 		true
 	end
 
-	def execute_action(action)
+	def execute_action(action, options={})
 		_, agent_name, _ = action['name'].split('.', 3)
 		agents = get_agents
 
@@ -58,7 +61,7 @@ module Nuri::Orchestrator
 		raise Exception, "Cannot find address:port of agent #{agent_name}" if
 			address.length <= 0 or port.length <= 0
 
-		send_action_data(action, address, port)
+		send_action_data(action, address, port, options)
 
 		data = {'action' => JSON.generate(action)}
 		code, _ = post_data(address, port, '/execute', data)
@@ -97,22 +100,22 @@ module Nuri::Orchestrator
 		}
 	end
 
-	def execute_sequential_plan(plan, p)
+	def execute_sequential_plan(plan, options)
 		begin
 			index = 1 
 			plan['workflow'].each do |action|
-				print "#{index}. #{action['name']} #{JSON.generate(action['parameters'])}... "
-				if execute_action(action)
-					puts "[OK]".green
+				puts "#{index}. #{action['name']} #{JSON.generate(action['parameters'])} " + (options[:color] ? "[Wait]".yellow : "[Wait]")
+				if execute_action(action, options)
+					puts "#{index}. #{action['name']} #{JSON.generate(action['parameters'])} " + (options[:color] ? "[OK]".green : "[OK]")
 				else
-					puts "[Failed]".red
+					puts "#{index}. #{action['name']} #{JSON.generate(action['parameters'])} " + (options[:color] ? "[Failed]".red : "[Failed]")
 					return false
 				end 
 				index += 1
 			end 
 			return true
 		rescue Exception => e
-			puts "#{e}\n#{e.backtrace.join("\n")}".red
+			$stderr.puts "#{e}\n#{e.backtrace.join("\n")}"
 		end 
 		false
 	end 
@@ -140,27 +143,28 @@ module Nuri::Orchestrator
 			id
 		end
 
-		def assign_action_with_id(id)
+		def assign_action_with_id(id, options={})
 			thread_id = next_thread_id
 			action = @actions[id]
 			action[:executor] = thread_id
-			self.thread_execute_action(thread_id, action)
+			self.thread_execute_action(thread_id, action, options)
 		end
 
-		def thread_execute_action(tid, action)
+		def thread_execute_action(tid, action, options={})
 			t = Thread.new {
 				# Register the thread
 				@mutex.synchronize { @threads << tid }
 
 				while not @failed and not action[:executed]
 					# Try to execute the action
-					puts "Executing #{action[:string]} - thread ##{tid} [WAIT]".yellow
+					puts "Executing #{action[:string]} - thread ##{tid} " + (options[:color] ? "[Wait]".yellow : "[Wait]")
 					success = false
 					1.upto(@retries) do |i|
 						begin
-							success = execute_action(action)
+							success = execute_action(action, options)
 						rescue Exception => exp
-							puts "Executing(#{i}) #{action[:string]} - thread ##{tid} [FAILED]\n#{exp}\n#{exp.backtrace.join("\n")}"
+							puts "Executing(#{i}) #{action[:string]} - thread ##{tid} " + (options[:color] ? "[Failed]".red : "[Failed]")
+							puts "#{exp}\n#{exp.backtrace.join("\n")}"
 						end
 						break if success
 					end
@@ -168,10 +172,10 @@ module Nuri::Orchestrator
 					# Check if execution failed
 					if success
 						# Execution was success
-						puts "Executing #{action[:string]} - thread ##{tid} [OK]".green
+						puts "Executing #{action[:string]} - thread ##{tid} " + (options[:color] ? "[OK]".green : "[OK]")
 						next_actions = []
 						@mutex.synchronize {
-							action[:executed] = true # set executed
+							action[:executed] = true # set executed flag
 							# select next action to be executed from successor actions list
 							# select a successor action that has not been assigned to any thread yet
 							if action['successors'].length > 0
@@ -196,14 +200,14 @@ module Nuri::Orchestrator
 							if next_actions.length > 1
 								# execute other next actions to other threads
 								for i in 1..(next_actions.length-1)
-									assign_action_with_id(next_actions[i])
+									assign_action_with_id(next_actions[i], options)
 								end
 							end
 						end
 
 					else
 						# Execution was failed
-						puts "Executing #{action[:string]} - thread ##{tid} [FAILED]".red
+						puts "Executing #{action[:string]} - thread ##{tid} " + (options[:color] ? "[Failed]".red : "[Failed]")
 						@mutex.synchronize {
 							@failed = true # set global flag to stop the execution
 							@actions_failed << action
@@ -215,7 +219,8 @@ module Nuri::Orchestrator
 			}
 		end
 
-		plan['init'].each { |id| assign_action_with_id(id) }
+		### execute actions without predecessor
+		plan['init'].each { |id| assign_action_with_id(id, options) }
 		begin
 			sleep 1
 		end while @threads.length > 0

data/modules/apache2/apache2.rb

@@ -0,0 +1,9 @@
+class Sfp::Module::Apache2
+	include Sfp::Resource
+
+	def update_state
+		@state['path'] = path
+		@state['installed'] = resolve(path + '.package.installed')
+		@state['running'] = resolve(path + '.service.running')
+	end
+end

data/modules/apache2/apache2.sfp

@@ -0,0 +1,54 @@
+include "../package2/package2.sfp"
+include "../service2/service2.sfp"
+
+schema Apache2 {
+	installed : Bool
+	running : Bool
+
+	package isa Package2 {
+		name = "apache2"
+		version = "latest"
+		provider = "apt"
+
+		synchronized sub install {
+			condition {
+				this.parent.installed != true
+			}
+			effect {
+				this.parent.installed = true
+				this.parent.running = true
+			}
+		}
+		synchronized sub uninstall {
+			condition {
+				this.parent.installed = true
+				this.parent.running = false
+			}
+			effect {
+				this.parent.installed = false
+			}
+		}
+	}
+
+	service isa Service2 {
+		name = "apache2"
+
+		sub start {
+			condition {
+				this.parent.installed = true
+			}
+			effect {
+				this.parent.running = true
+			}
+		}
+	
+		sub stop {
+			condition {
+				this.parent.running = true
+			}
+			effect {
+				this.parent.running = false
+			}
+		}
+	}
+}

data/modules/file/file.rb

@@ -7,7 +7,7 @@ class Sfp::Module::File
 
 	##############################
 	#
-	# update current state method
+	# method to update current state
 	#
 	##############################
 

data/modules/file/file.sfp

@@ -1,5 +1,5 @@
 schema File {
-	exists is true
+	exists : Bool
 
 	final path is ""
 	final content : String

data/modules/machine/machine.rb

@@ -4,6 +4,8 @@ class Sfp::Module::Machine
 	def update_state
 		to_model
 
+		load_kernel_modules(['acpiphp'])
+
 		@state['sfpAddress'] = @model['sfpAddress']
 		@state['sfpPort'] = @model['sfpPort']
 		@state['created'] = true
@@ -29,6 +31,21 @@ class Sfp::Module::Machine
 
 	protected
 
+	def load_kernel_modules(modules=[])
+		loaded = []
+		`lsmod`.each_line do |line|
+			next if line.strip.length <= 0
+			name, size, used, by = line.split(' ', 4)
+			next if name.to_s.downcase == 'module'
+			loaded << name
+		end
+
+		unloaded = modules - loaded
+		unloaded.each do |name|
+			shell "modprobe #{name}"
+		end
+	end
+
 	# generate the disks' state, try to automatically mount the disk to target directory
 	#
 	def get_disk_state

data/modules/package2/package2.rb

@@ -0,0 +1,85 @@
+require 'thread'
+
+class Sfp::Module::Package2
+	include Sfp::Resource
+
+	def update_state
+		to_model
+
+		@state['installed'] = installed?
+		@state['version'] = version?
+	end
+
+	##############################
+	#
+	# Action methods (see Package2.sfp)
+	#
+	##############################
+
+	@@lock = Mutex.new
+
+	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
+			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
+			""
+		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
+			else
+				shell "dpkg --configure -a; apt-get -y update && apt-get -y install #{name}"
+			end
+		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"
+		end
+	end
+
+=begin
+	protected
+	def installed?
+		Sfp::Module::AptPackage.installed?(@model['package_name'].to_s.strip)
+	end
+
+	def version?
+		package = @model['package_name'].to_s.strip
+		return "" if package.length <= 0
+		installed = `apt-cache policy #{package} | grep Installed`.strip.split(' ', 2)[1].to_s.strip
+		return "" if installed.length <= 0
+		candidate = `apt-cache policy #{package} | grep Candidate`.strip.split(' ', 2)[1].to_s.strip
+		return "latest" if candidate == installed
+		installed
+	end
+=end
+end

data/modules/package2/package2.sfp

@@ -0,0 +1,23 @@
+schema Package2 {
+	installed : Bool
+
+	final name = ""
+	final version = "latest"
+	final source = "default"
+	final provider = "apt"
+
+	synchronized sub install {
+		effect {
+			this.installed = true
+		}
+	}
+
+	synchronized sub uninstall {
+		condition {
+			this.installed = true
+		}
+		effect {
+			this.installed = false
+		}
+	}
+}

data/modules/pyfile/main

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+
+import sys
+import json
+import os
+import hashlib
+import io
+from subprocess import call
+
+
+###############
+#
+# Method for generating current state
+#
+###############
+def get_state(model):
+	state = {}
+	state['path'] = model['path'] if 'path' in model else ''
+	try:
+		m = hashlib.md5()
+		with open(state['path']) as f:
+			buf = f.read(128)
+			while len(buf) > 0:
+				m.update(buf)
+				buf = f.read(128)
+		state['created'] = True
+		state['content'] = '{md5}' + m.hexdigest()
+	except IOError:
+		state['created'] = False
+		state['content'] = ''
+
+	if state['created'] and 'content' in model:
+		m = hashlib.md5()
+		m.update(model['content'])
+		state['created'] = (('{md5}' + m.hexdigest()) == state['content'])
+
+	### dump current state
+	print json.dumps(state)
+
+
+###############
+#
+# Implementation of procedure 'del' (see pyfile.sfp)
+#
+###############
+def delete(model):
+	if 'path' in model:
+		os.remove(model['path'])
+	else:
+		return False
+	return True
+
+
+###############
+#
+# Implementation of procedure 'create' (see pyfile.sfp)
+#
+###############
+def create(model):
+	if 'path' in model:
+		content = model['content'] if 'content' in model else ''
+		try:
+			with open(model['path'], 'w') as f:
+				f.write(content)
+		except IOError, e:
+			print str(e)
+			return False
+	else:
+		return False
+
+	if 'permission' in model:
+		call(["chmod", model['permission'], model['path']])
+
+	return True
+
+
+###############
+#
+# Function to redirect procedure execution request by
+# calling target function
+#
+###############
+def execute(procedure, parameters, model):
+	success = False
+	description = ''
+	if procedure == 'del':
+		success = delete(model)
+	elif procedure == 'create':
+		success = create(model)
+	else:
+		description = 'unrecognized procedure ' + procedure
+	status = 'ok' if success else 'failed'
+	print json.dumps({'status': status, 'description': description})
+
+
+###############
+#
+# Main logic for handling any request
+#
+###############
+if len(sys.argv) <= 1:
+	### invalid request
+	print '{"status":"error","description":"invalid command line argument"}'
+	exit(1)
+else:
+	### parse request data in JSON
+	data = json.loads(sys.argv[1])
+
+	if 'command' in data:
+		try:
+			if data['command'] == 'state' and 'model' in data:
+				### request for current state
+				get_state(data['model'])
+
+			elif data['command'] == 'execute' and 'procedure' in data and 'parameters' in data and 'model' in data:
+				### request for executing a procedure
+				execute(data['procedure'], data['parameters'], data['model'])
+
+			else:
+				### invalid request
+				print '{"status":"error","description":"invalid command"}'
+				exit(1)
+
+		except Exception, e:
+			### dump exception
+			print json.dumps({'status':'error','description': str(e)})
+
+	else:
+		### invalid request
+		print '{"status":"error","description":"no command"}'
+		exit(1)
+
+exit(0)