sfpagent 0.1.13 → 0.1.14

data/VERSION

@@ -1 +1 @@
-0.1.13
+0.1.14

data/bin/install_module

@@ -0,0 +1,63 @@
+#!/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"
+
+# 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 /tmp/$module.tgz $module 1>/dev/null
+		cmd="$cmd -F $module=@/tmp/$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 temporary archive files
+for module in "$@"; do
+	rm -f /tmp/$module.tgz
+done
+
+if [[ $missing_module == 0 ]]; then
+	echo "status: ok"
+else
+	echo "status: failed"
+fi
+
+exit $missing_module

data/bin/sfpagent

@@ -48,8 +48,7 @@ elsif opts[:stop]
 
 elsif opts[:restart]
 	opts[:daemon] = true
-	Sfp::Agent.stop
-	Sfp::Agent.start(opts)
+	Sfp::Agent.start(opts) if Sfp::Agent.stop
 
 elsif opts[:status]
 	Sfp::Agent.status

data/lib/sfpagent/agent.rb

@@ -11,21 +11,23 @@ require 'digest/md5'
 
 module Sfp
 	module Agent
-		NetHelper = Object.new.extend(Nuri::Net::Helper)
+		NetHelper = Object.new.extend(Sfp::Net::Helper)
 
-		CachedDir = (Process.euid == 0 ? '/var/sfpagent' : File.expand_path('~/.sfpagent'))
-		Dir.mkdir(CachedDir, 0700) if not File.exist?(CachedDir)
+		CacheDir = (Process.euid == 0 ? '/var/sfpagent' : File.expand_path('~/.sfpagent'))
+		Dir.mkdir(CacheDir, 0700) if not File.exist?(CacheDir)
 
 		DefaultPort = 1314
 
-		PIDFile = "#{CachedDir}/sfpagent.pid"
-		LogFile = "#{CachedDir}/sfpagent.log"
-		ModelFile = "#{CachedDir}/sfpagent.model"
-		AgentsDataFile = "#{CachedDir}/sfpagent.agents"
+		PIDFile = "#{CacheDir}/sfpagent.pid"
+		LogFile = "#{CacheDir}/sfpagent.log"
+		ModelFile = "#{CacheDir}/sfpagent.model"
+		AgentsDataFile = "#{CacheDir}/sfpagent.agents"
 
-		BSigFile = "#{CachedDir}/bsig.model"
-		BSigPIDFile = "#{CachedDir}/bsig.pid"
-		BSigThreadsLockFile = "#{CachedDir}/bsig.threads.lock.#{Time.now.nsec}"
+		CacheModelFile = "#{CacheDir}/cache.model"
+
+		BSigFile = "#{CacheDir}/bsig.model"
+		BSigPIDFile = "#{CacheDir}/bsig.pid"
+		BSigThreadsLockFile = "#{CacheDir}/bsig.threads.lock.#{Time.now.nsec}"
 
 		@@logger = WEBrick::Log.new(LogFile, WEBrick::BasicLog::INFO ||
 		                                     WEBrick::BasicLog::ERROR ||
@@ -47,6 +49,10 @@ module Sfp
 			@@logger
 		end
 
+		def self.config
+			@@config
+		end
+
 		# Start the agent.
 		#
 		# options:
@@ -60,11 +66,11 @@ module Sfp
 			Sfp::Agent.logger.info "Starting SFP Agent daemons..."
 			puts "Starting SFP Agent daemons..."
 
-			Process.daemon
+			Process.daemon if p[:daemon]
 
 			begin
 				# check modules directory, and create it if it's not exist
-				p[:modules_dir] = File.expand_path(p[:modules_dir].to_s.strip != '' ? p[:modules_dir].to_s : "#{CachedDir}/modules")
+				p[:modules_dir] = File.expand_path(p[:modules_dir].to_s.strip != '' ? p[:modules_dir].to_s : "#{CacheDir}/modules")
 				Dir.mkdir(p[:modules_dir], 0700) if not File.exist?(p[:modules_dir])
 				@@config = p
 
@@ -97,6 +103,10 @@ module Sfp
 					trap(signal) {
 						Sfp::Agent.logger.info "Shutting down web server and BSig engine..."
 						bsig_engine.stop
+						loop do
+							break if bsig_engine.status == :stopped
+							sleep 1
+						end
 						server.shutdown
 					}
 				}
@@ -121,19 +131,23 @@ module Sfp
 				puts "Stopping SFP Agent with PID #{pid}..."
 				Process.kill 'HUP', pid
 
-				sleep (Sfp::BSig::SleepTime + 0.25)
-
-				# forcely kill the process if it is still running
-				system("kill -9 #{pid} 1>/dev/null 2>/dev/null")
-
-				Sfp::Agent.logger.info "SFP Agent daemon has stopped."
-				puts "SFP Agent daemon has stopped."
+				begin
+					sleep (Sfp::BSig::SleepTime + 0.25)
+					Process.kill 0, pid
+					Sfp::Agent.logger.info "SFP Agent daemon is still running."
+					puts "SFP Agent daemon is still running."
+					return false
+				rescue
+					Sfp::Agent.logger.info "SFP Agent daemon has stopped."
+					puts "SFP Agent daemon has stopped."
+					File.delete(PIDFile) if File.exist?(PIDFile)
+				end
 			rescue
 				puts "SFP Agent is not running."
+				File.delete(PIDFile) if File.exist?(PIDFile)
 			end
 
-		ensure
-			File.delete(PIDFile) if File.exist?(PIDFile)
+			true
 		end
 
 		# Print the status of the agent.
@@ -149,6 +163,39 @@ module Sfp
 			end
 		end
 
+		def self.get_cache_model(name)
+			model = JSON[File.read(CacheModelFile)]
+			(model.has_key?(name) ? model[name] : nil)
+		end
+
+		def self.set_cache_model(p={})
+			File.open(CacheModelFile, File::RDWR|File::CREAT, 0600) do |f|
+				f.flock(File::LOCK_EX)
+				json = f.read
+				model = (json.length >= 2 ? JSON[json] : {})
+
+				if p[:name]
+					if p[:model]
+						model[p[:name]] = p[:model]
+						Sfp::Agent.logger.info "Setting cache model for #{p[:name]}..."
+					else
+						model.delete(p[:name]) if model.has_key?(p[:name])
+						Sfp::Agent.logger.info "Deleting cache model for #{p[:name]}..."
+					end
+				else
+					model = {}
+					Sfp::Agent.logger.info "Deleting all cache model..."
+				end
+
+				f.rewind
+				f.write(JSON.generate(model))
+				f.flush
+				f.truncate(f.pos)
+			end
+
+			true
+		end
+
 		# Save given model to cached file, and then reload the model.
 		#
 		def self.set_model(model)
@@ -342,7 +389,7 @@ module Sfp
 			Sfp::Agent.logger.info "Successfully loading #{counter} modules."
 		end
 
-		def self.get_schemata(module_name)
+		def self.get_sfp(module_name)
 			dir = @@config[:modules_dir]
 
 			filepath = "#{dir}/#{module_name}/#{module_name}.sfp"
@@ -372,6 +419,23 @@ module Sfp
 			data
 		end
 
+		# Push a list of modules to an agent using a script in $SFPAGENT_HOME/bin/install_module.
+		#
+		# parameters:
+		#   :address => address of target agent
+		#   :port    => port of target agent
+		#   :modules => an array of modules' name that will be pushed
+		#
+		def self.push_modules(p={})
+			fail "Incomplete parameters." if !p[:modules] or !p[:address] or !p[:port]
+
+			install_module = File.expand_path('../../../bin/install_module', __FILE__)
+			modules = p[:modules].join(' ')
+			cmd = "cd #{@@config[:modules_dir]}; #{install_module} #{p[:address]} #{p[:port]} #{modules}"
+			result = `#{cmd}`
+			(result =~ /status: ok/)
+		end
+
 		def self.uninstall_all_modules(p={})
 			return true if @@config[:modules_dir] == ''
 			if system("rm -rf #{@@config[:modules_dir]}/*")
@@ -397,8 +461,16 @@ module Sfp
 			result
 		end
 
-		def self.install_module(name, data)
-			return false if @@config[:modules_dir].to_s == ''
+		def self.install_modules(modules)
+			modules.each { |name,data| return false if not install_module(name, data, false) }
+
+			load_modules(@@config)
+
+			true
+		end
+
+		def self.install_module(name, data, reload=true)
+			return false if @@config[:modules_dir].to_s == '' or data.nil?
 
 			if !File.directory? @@config[:modules_dir]
 				File.delete @@config[:modules_dir] if File.exist? @@config[:modules_dir]
@@ -422,11 +494,9 @@ module Sfp
 				end
 				system("cd #{module_dir}; rm data.tgz")
 			}
-			load_modules(@@config)
-			
-			# rebuild the model
-			update_model({:rebuild => true})
 
+			load_modules(@@config) if reload
+			
 			Sfp::Agent.logger.info "Installing module #{name} [OK]"
 
 			true
@@ -441,22 +511,52 @@ module Sfp
 			end
 		end
 
-		def self.set_agents(agents)
-			File.open(AgentsDataFile, 'w', 0600) do |f|
-				raise Exception, "Invalid agents list." if not agents.is_a?(Hash)
-				buffer = {}
-				agents.each { |name,data|
-					raise Exception, "Invalid agents list." if not data.is_a?(Hash) or
-						not data.has_key?('sfpAddress') or data['sfpAddress'].to_s.strip == '' or
-						not data.has_key?('sfpPort')
-					buffer[name] = {}
-					buffer[name]['sfpAddress'] = data['sfpAddress'].to_s
-					buffer[name]['sfpPort'] = data['sfpPort'].to_s.strip.to_i
-					buffer[name]['sfpPort'] = DefaultPort if buffer[name]['sfpPort'] == 0
+		# parameter:
+		#   :data => To delete an agent: { "agent_name" => nil }
+		#            To add/modify an agent: { "agent_name" => { "sfpAddress" => "10.0.0.1", "sfpPort" => 1314 } }
+		#
+		def self.set_agents(data)
+			data.each { |name,agent|
+				return false if agent.is_a?(Hash) and (not agent['sfpAddress'].is_a?(String) or
+				                agent['sfpAddress'].strip == '' or agent['sfpPort'].to_i <= 0)
+			}
+
+			updated = false
+			agents = nil
+			File.open(AgentsDataFile, File::RDWR|File::CREAT, 0644) { |f|
+				f.flock(File::LOCK_EX)
+				json = f.read
+				agents = (json == '' ? {} : JSON[json])
+				current_hash = agents.hash
+				data.each { |k,v|
+					if !agents.has_key?(k) or v.nil? or agents[k].hash != v.hash
+						agents[k] = v
+					end
+				}
+				agents.keys.each { |k| agents.delete(k) if agents[k].nil? }
+
+				if current_hash != agents.hash
+					updated = true
+					f.rewind
+					f.write(JSON.generate(agents))
+					f.flush
+					f.truncate(f.pos)
+				end
+			}
+
+			if updated # if updated then broadcast to other agents
+				http_data = {'agents' => JSON.generate(data)}
+
+				agents.each { |name,agent|
+					begin
+						code, _ = NetHelper.put_data(agent['sfpAddress'], agent['sfpPort'], '/agents', http_data, 5, 20)
+						raise Exception if code != '200'
+					rescue Exception => e
+						Sfp::Agent.logger.warn "Push agents list to #{agent['sfpAddress']}:#{agent['sfpPort']} [Failed]"
+					end
 				}
-				f.write(JSON.generate(buffer))
-				f.flush
 			end
+
 			true
 		end
 
@@ -479,15 +579,15 @@ module Sfp
 			#	/pid      => save daemon's PID to a file (only requested from localhost)
 			#	/state    => return the current state
 			#	/model    => return the current model
-			#	/schemata => return the schemata of a module
+			#	/sfp      => return the SFP description of a module
 			#	/modules  => return a list of available modules
 			#  /agents   => return a list of agents database
 			#  /log      => return last 100 lines of log file
 			#
 			def do_GET(request, response)
 				status = 400
-				content_type, body = ''
-				if not trusted(request.peeraddr[2])
+				content_type = body = ''
+				if not trusted(request)
 					status = 403
 				else
 					path = (request.path[-1,1] == '/' ? request.path.chop : request.path)
@@ -509,11 +609,14 @@ module Sfp
 					elsif path == '/model'
 						status, content_type, body = get_model
 
+					elsif path =~ /\/model\/cache\/.+/
+						status, content_type, body = self.get_cache_model({:name => path[13, path.length-13]})
+
 					elsif path == '/bsig'
 						status, content_Type, body = get_bsig
 
-					elsif path =~ /^\/schemata\/.+/
-						status, content_type, body = get_schemata({:module => path[10, path.length-10]})
+					elsif path =~ /^\/sfp\/.+/
+						status, content_type, body = get_sfp({:module => path[10, path.length-10]})
 
 					elsif path == '/modules'
 						status, content_type, body = [200, 'application/json', JSON.generate(Sfp::Agent.get_modules)]
@@ -540,7 +643,7 @@ module Sfp
 			def do_POST(request, response)
 				status = 400
 				content_type, body = ''
-				if not self.trusted(request.peeraddr[2])
+				if not self.trusted(request)
 					status = 403
 				else
 					path = (request.path[-1,1] == '/' ? ryyequest.path.chop : request.path)
@@ -557,36 +660,40 @@ module Sfp
 			# Handle HTTP Put request
 			#
 			# uri:
-			#	/model          => receive a new model and save to cached file
+			#	/model          => receive a new model and then save it
+			#  /model/cache    => receive a "cache" model and then save it
 			#	/modules        => save the module if parameter "module" is provided
-			#                     delete the module if parameter "module" is not provided
 			#	/agents         => save the agents' list if parameter "agents" is provided
-			#	                   delete all agents if parameter "agents" is not provided
 			#  /bsig           => receive BSig model and receive it in cached directory
 			#  /bsig/satisfier => receive goal request from other agents and then start
 			#                     a satisfier thread to try to achieve it
+			#
 			def do_PUT(request, response)
 				status = 400
-				content_type, body = ''
-				if not self.trusted(request.peeraddr[2])
+				content_type = body = ''
+				if not self.trusted(request)
 					status = 403
 				else
 					path = (request.path[-1,1] == '/' ? ryyequest.path.chop : request.path)
 
-					if path == '/model'
+					if path == '/model' and request.query.has_key?('model')
 						status, content_type, body = self.set_model({:query => request.query})
 
-					elsif path =~ /\/modules\/.+/
+					elsif path =~ /\/model\/cache\/.+/ and request.query.length > 0
+						status, content_type, body = self.set_cache_model({:name => path[13, path.length-13],
+						                                                   :query => request.query})
+
+					elsif path =~ /\/modules\/.+/ and request.query.length > 0
 						status, content_type, body = self.manage_modules({:name => path[9, path.length-9],
 						                                                  :query => request.query})
 
-					elsif path == '/modules'
-						status, content_type, body = self.manage_modules({:delete => true})
+					elsif path == '/modules' and request.query.length > 0
+						status, content_type, body = self.manage_modules({:query => request.query})
 
-					elsif path == '/agents'
-						status, content_type, body = self.manage_agents({:query => request.query})
+					elsif path == '/agents' and request.query.has_key?('agents')
+						status, content_type, body = self.set_agents({:query => request.query})
 
-					elsif path == '/bsig'
+					elsif path == '/bsig' and request.query.has_key?('bsig')
 						status, content_type, body = self.set_bsig({:query => request.query})
 
 					elsif path == '/bsig/satisfier'
@@ -600,9 +707,52 @@ module Sfp
 				response.body = body
 			end
 
-			def manage_agents(p={})
+			# Handle HTTP Put request
+			#
+			# uri:
+			#	/model          => delete existing model
+			#	/modules        => delete a module with name specified in parameter "module", or
+			#	                   delete all modules if parameter "module" is not provided
+			#	/agents         => delete agents database
+			#  /bsig           => delete existing BSig model
+			#
+			def do_DELETE(request, response)
+				status = 400
+				content_type = body = ''
+				if not self.trusted(request)
+					status = 403
+				else
+					path = (request.path[-1,1] == '/' ? ryyequest.path.chop : request.path)
+
+					if path == '/model'
+						status, content_type, body = self.set_model
+
+					elsif path == '/model/cache'
+						status, content_type, body = self.set_cache_model
+
+					elsif path =~ /\/model\/cache\/.+/
+						status, content_type, body = self.set_cache_model({:name => path[13, path.length-13]})
+
+					elsif path == '/modules'
+						status, content_type, body = self.manage_modules({:deleteall => true})
+
+					elsif path =~ /\/modules\/.+/
+						status, content_type, body = self.manage_modules({:name => path[9, path.length-9]})
+
+					elsif path == '/agents'
+						status, content_type, body = self.set_agents
+
+					elsif path == '/bsig'
+						status, content_type, body = self.set_bsig
+
+					end
+
+				end
+			end
+
+			def set_agents(p={})
 				begin
-					if p[:query].has_key?('agents')
+					if p[:query] and p[:query].has_key?('agents')
 						return [200, '', ''] if Sfp::Agent.set_agents(JSON[p[:query]['agents']])
 					else
 						return [200, '', ''] if Sfp::Agent.set_agents({})
@@ -614,23 +764,47 @@ module Sfp
 			end
 
 			def manage_modules(p={})
-				if p[:delete]
-					return [200, '', ''] if Sfp::Agent.uninstall_all_modules
-				else
-					p[:name], _ = p[:name].split('/', 2)
-					if p[:query].has_key?('module')
+				if p[:name]
+					if p[:query]
 						return [200, '', ''] if Sfp::Agent.install_module(p[:name], p[:query]['module'])
 					else
 						return [200, '', ''] if Sfp::Agent.uninstall_module(p[:name])
 					end
+				elsif p[:query].length > 0
+					return [200, '', ''] if Sfp::Agent.install_modules(p[:query])
+				else
+					return [200, '', ''] if Sfp::Agent.uninstall_all_modules
 				end
+
 				[500, '', '']
 			end
 
-			def get_schemata(p={})
+			def get_cache_model(p={})
+				model = Sfp::Agent.get_cache_model(p[:name])
+				if model
+					[200, 'application/json', JSON.generate(model)]
+				else
+					[404, '', '']
+				end
+			end
+
+			def set_cache_model(p={})
+				p[:model] = JSON[p[:query]['model']] if p[:query].is_a?(Hash) and p[:query]['model']
+
+				if p[:name]
+					return [200, '', ''] if Sfp::Agent.set_cache_model(p)
+				else
+					return [200, '', ''] if Sfp::Agent.set_cache_model
+				end
+
+				[500, '', '']
+			end
+
+
+			def get_sfp(p={})
 				begin
 					module_name, _ = p[:module].split('/', 2)
-					return [200, 'application/json', Sfp::Agent.get_schemata(module_name)]
+					return [200, 'application/json', Sfp::Agent.get_sfp(module_name)]
 				rescue Exception => e
 					@logger.error "Sending schemata [Failed]\n#{e}"
 				end
@@ -680,7 +854,7 @@ module Sfp
 			end
 
 			def execute(p={})
-				return [400, '', ''] if not p[:query].has_key?('action')
+				return [400, '', ''] if not (p[:query] and p[:query].has_key?('action'))
 				begin
 					return [200, '', ''] if Sfp::Agent.execute_action(JSON[p[:query]['action']])
 				rescue
@@ -733,7 +907,7 @@ module Sfp
 				[500, '', '']
 			end
 
-			def trusted(address)
+			def trusted(request)
 				true
 			end
 

data/lib/sfpagent/bsig.rb

@@ -1,14 +1,14 @@
 require 'thread'
 
 class Sfp::BSig
-	include Nuri::Net::Helper
+	include Sfp::Net::Helper
 
 	SleepTime = 5
 	MaxTries = 5
 
 	SatisfierPath = '/bsig/satisfier'
-	CachedDir = (Process.euid == 0 ? '/var/sfpagent' : File.expand_path('~/.sfpagent'))
-	SatisfierLockFile = "#{CachedDir}/bsig.satisfier.lock.#{Time.now.nsec}"
+	CacheDir = (Process.euid == 0 ? '/var/sfpagent' : File.expand_path('~/.sfpagent'))
+	SatisfierLockFile = "#{CacheDir}/bsig.satisfier.lock.#{Time.now.nsec}"
 
 	attr_reader :enabled, :status, :mode
 
@@ -16,6 +16,7 @@ class Sfp::BSig
 		@lock = Mutex.new
 		@enabled = false
 		@status = :stopped
+		@lock_postprocess = Mutex.new
 	end
 
 	def stop
@@ -32,7 +33,7 @@ class Sfp::BSig
 		Thread.new {
 			register_satisfier_thread(:reset)
 	
-			system("rm -f #{CachedDir}/operator.*.lock")
+			system("rm -f #{CacheDir}/operator.*.lock")
 	
 			Sfp::Agent.logger.info "[main] BSig engine is running."
 	
@@ -107,7 +108,8 @@ class Sfp::BSig
 		operator = select_operator(flaws, operators, pi)
 		return :failure if operator.nil?
 
-#Sfp::Agent.logger.info "[#{mode}] Flaws: #{JSON.generate(flaws)}"  # debugging
+# debugging
+#Sfp::Agent.logger.info "[#{mode}] Flaws: #{JSON.generate(flaws)}"
 
 		return :ongoing if not lock_operator(operator)
 
@@ -116,7 +118,8 @@ class Sfp::BSig
 		next_pi = operator['pi'] + 1
 		pre_local, pre_remote = split_preconditions(operator)
 
-#Sfp::Agent.logger.info "[#{mode}] local-flaws: #{JSON.generate(pre_local)}, remote-flaws: #{JSON.generate(pre_remote)}"  # debugging
+# debugging
+#Sfp::Agent.logger.info "[#{mode}] local-flaws: #{JSON.generate(pre_local)}, remote-flaws: #{JSON.generate(pre_remote)}"
 
 		status = nil
 		tries = MaxTries
@@ -146,17 +149,29 @@ class Sfp::BSig
 	end
 
 	def achieve_remote_goal(id, goal, pi, mode)
+
 		if goal.length > 0
 			agents = Sfp::Agent.get_agents
 			split_goal_by_agent(goal).each do |agent_name,agent_goal|
-				return false if not agents.has_key?(agent_name) or agents[agent_name]['sfpAddress'].to_s == ''
-
-				return false if not send_goal_to_agent(agents[agent_name], id, agent_goal, pi, agent_name, mode)
+				if agents.has_key?(agent_name)
+					return false if agents[agent_name]['sfpAddress'].to_s == ''
+					return false if not send_goal_to_agent(agents[agent_name], id, agent_goal, pi, agent_name, mode)
+				else
+					return false if not verify_state_of_not_exist_agent(agent_name, agent_goal)
+				end
 			end
 		end
 		true
 	end
 
+	def verify_state_of_not_exist_agent(name, goal)
+		state = { name => { 'created' => false } }
+		goal.each { |var,val|
+			return false if state.at?(var) != val
+		}
+		true
+	end
+
 	def receive_goal_from_agent(id, goal, pi)
 		register_satisfier_thread
 
@@ -187,7 +202,7 @@ class Sfp::BSig
 		unregister_satisfier_thread
 	end
 
-	protected
+	#protected
 	def register_satisfier_thread(mode=nil)
 		File.open(SatisfierLockFile, File::RDWR|File::CREAT, 0644) { |f|
 			f.flock(File::LOCK_EX)
@@ -212,7 +227,7 @@ class Sfp::BSig
 
 	def lock_operator(operator)
 		@lock.synchronize {
-			operator_lock_file = "#{CachedDir}/operator.#{operator['name']}.lock"
+			operator_lock_file = "#{CacheDir}/operator.#{operator['name']}.lock"
 			return false if File.exist?(operator_lock_file)
 			File.open(operator_lock_file, 'w') { |f| f.write('1') }
 			return true
@@ -221,17 +236,17 @@ class Sfp::BSig
 
 	def unlock_operator(operator)
 		@lock.synchronize {
-			operator_lock_file = "#{CachedDir}/operator.#{operator['name']}.lock"
+			operator_lock_file = "#{CacheDir}/operator.#{operator['name']}.lock"
 			File.delete(operator_lock_file) if File.exist?(operator_lock_file)
 		}
 	end
 
 	def split_goal_by_agent(goal)
-		agents = Sfp::Agent.get_agents
+		#agents = Sfp::Agent.get_agents
 		agent_goal = {}
 		goal.each { |var,val|
 			_, agent_name, _ = var.split('.', 3)
-			fail "Agent #{agent_name} is not in database!" if not agents.has_key?(agent_name)
+			#fail "Agent #{agent_name} is not in database!" if not agents.has_key?(agent_name)
 			agent_goal[agent_name] = {} if not agent_goal.has_key?(agent_name)
 			agent_goal[agent_name][var] = val
 		}
@@ -239,17 +254,21 @@ class Sfp::BSig
 	end
 
 	def send_goal_to_agent(agent, id, g, pi, agent_name='', mode)
-		data = {'id' => id,
-		        'goal' => JSON.generate(g),
-		        'pi' => pi}
-
-		Sfp::Agent.logger.info "[#{mode}] Request goal to: #{agent_name} [WAIT]"
-
-		code, _ = put_data(agent['sfpAddress'], agent['sfpPort'], SatisfierPath, data)
-
-		Sfp::Agent.logger.info "[#{mode}] Request goal to: #{agent_name} - status: #{code}"
-
-		(code == '200')
+		begin
+			data = {'id' => id,
+			        'goal' => JSON.generate(g),
+			        'pi' => pi}
+	
+			Sfp::Agent.logger.info "[#{mode}] Request goal to: #{agent_name} [WAIT]"
+	
+			code, _ = put_data(agent['sfpAddress'], agent['sfpPort'], SatisfierPath, data)
+	
+			Sfp::Agent.logger.info "[#{mode}] Request goal to: #{agent_name} - status: #{code}"
+	
+			(code == '200')
+		rescue
+			false
+		end
 	end
 
 	def get_current_state
@@ -262,7 +281,13 @@ class Sfp::BSig
 		return goal.clone if current.nil?
 		flaws = {}
 		goal.each { |var,val|
-			current_value = current.at?(var)
+			_, agent_name, _ = var.split('.', 3)
+			if agent_name != Sfp::Agent.whoami?
+				current_value = Sfp::Resource.resolve(var)
+			else
+				current_value = current.at?(var)
+			end
+
 			if current_value.is_a?(Sfp::Undefined)
 				flaws[var] = val if not val.is_a?(Sfp::Undefined)
 			else
@@ -312,6 +337,150 @@ class Sfp::BSig
 
 	def invoke(operator, mode)
 		Sfp::Agent.logger.info "[#{mode}] Invoking #{operator['name']}"
-		Sfp::Agent.execute_action(operator)
+
+		begin
+			status = Sfp::Agent.execute_action(operator)
+			if status
+				if operator['name'] =~ /^\$(\.[a-zA-Z0-9_]+)*\.(create_vm)/
+					postprocess_create_vm(operator)
+				elsif operator['name'] =~ /^\$(\.[a-zA-Z0-9_]+)*\.(delete_vm)/
+					postprocess_delete_vm(operator)
+				end
+			end
+		rescue Exception => e
+			Sfp::Agent.logger.error "Error in invoking operator #{operator['name']}\n#{e}\n#{e.backtrace.join("\n")}"
+			return false
+		end
+
+		status
+	end
+
+	def postprocess_delete_vm(operator)
+		@lock_postprocess.synchronize {
+			_, agent_name, _ = operator['name'].split('.', 3)
+
+Sfp::Agent.logger.info "Postprocess delete VM #{agent_name}"
+
+			# update agents database (automatically broadcast to other agents)
+			Sfp::Agent.set_agents({agent_name => nil})
+		}
+	end
+
+	def postprocess_create_vm(operator)
+		@lock_postprocess.synchronize {
+			refs = operator['name'].split('.')
+			vms_ref = refs[0..-2].join('.') + '.vms'
+
+			_, agent_name, _ = operator['parameters']['$.vm'].split('.', 3)
+
+Sfp::Agent.logger.info "Postprocess create VM #{agent_name}"
+
+			# update proxy component's state
+			state = Sfp::Agent.get_state
+			return false if not state.is_a?(Hash)
+
+			# get VM's address
+			vms = state.at?(vms_ref)
+			return false if !vms.is_a?(Hash) or !vms[agent_name].is_a?(Hash) or vms[agent_name]['ip'].to_s.strip == ''
+			data = {agent_name => {'sfpAddress' => vms[agent_name]['ip'], 'sfpPort' => Sfp::Agent::DefaultPort}}
+
+			# update agents database
+			Sfp::Agent.set_agents(data)
+
+			# get new agent's model and BSig model from cache database
+			model = Sfp::Agent.get_cache_model(agent_name)
+			model['model']['in_cloud'] = refs[0..-2].join('.')
+			
+			if not model.nil?
+				address = data[agent_name]['sfpAddress']
+				port = data[agent_name]['sfpPort']
+
+				# push required modules
+				push_modules(model, address, port)
+
+				# push agent database to new agent
+				code, _ = put_data(address, port, '/agents', {'agents' => JSON.generate(Sfp::Agent.get_agents)})
+
+				# push new agent's model
+				code, _ = put_data(address, port, '/model', {'model' => JSON.generate({agent_name => model['model']})})
+
+				# push new agent's BSig model
+				code, _ = put_data(address, port, '/bsig', {'bsig' => JSON.generate(model['bsig'])}) if code == '200'
+
+				return (code == '200')
+			end
+		}
+		false
 	end
+
+	def push_modules(agent_model, address, port)
+		name = agent_model['_self']
+		finder = Sfp::Helper::SchemaCollector.new
+		{:agent => agent_model}.accept(finder)
+		schemata = finder.schemata.uniq.map { |x| x.sub(/^\$\./, '').downcase }
+
+		modules_dir = Sfp::Agent.config[:modules_dir]
+		install_module = File.expand_path('../../../bin/install_module', __FILE__)
+
+		begin
+			# get modules list
+			code, body = get_data(address, port, '/modules')
+			raise Exception, "Unable to get modules list from #{name}" if code.to_i != 200
+
+			modules = JSON[body]
+			list = ''
+			schemata.each { |m|
+				list += "#{m} " if m != 'object' and File.exist?("#{modules_dir}/#{m}") and
+				                   (not modules.has_key?(m) or modules[m] != get_local_module_hash(m, modules_dir).to_s)
+			}
+
+			return true if list == ''
+
+			if system("cd #{modules_dir}; #{install_module} #{address} #{port} #{list} 1>/dev/null 2>/tmp/install_module.error")
+				Sfp::Agent.logger.info "Push modules #{list}to #{name} [OK]"
+			else
+				Sfp::Agent.logger.warn "Push modules #{list}to #{name} [Failed]"
+			end
+
+			return true
+
+		rescue Exception => e
+			Sfp::Agent.logger.warn "[WARN] Cannot push module to #{name} - #{e}"
+		end
+
+		false
+	end
+
+	# return the list of Hash value of all modules
+	#
+	def get_local_module_hash(name, modules_dir)
+		module_dir = File.expand_path("#{modules_dir}/#{name}")
+		if File.directory? module_dir
+			if `which md5sum`.strip.length > 0
+				return `find #{module_dir} -type f -exec md5sum {} + | awk '{print $1}' | sort | md5sum | awk '{print $1}'`.strip
+			elsif `which md5`.strip.length > 0
+				return `find #{module_dir} -type f -exec md5 {} + | awk '{print $4}' | sort | md5`.strip
+			end
+		end
+		nil
+	end
+
 end
+
+module Sfp::Helper
+end
+
+class Sfp::Helper::SchemaCollector
+	attr_reader :schemata
+	def initialize
+		@schemata = []
+	end
+		
+	def visit(name, value, parent)
+		if value.is_a?(Hash) and value.has_key?('_classes')
+			value['_classes'].each { |s| @schemata << s }
+		end
+		true
+	end
+end
+

data/lib/sfpagent/module.rb

@@ -2,6 +2,12 @@
 # predefined methods: update_state, apply, reset, resolve
 #
 module Sfp::Resource
+	@@resource = Object.new.extend(Sfp::Resource)
+
+	def self.resolve(path)
+		@@resource.resolve(path)
+	end
+
 	attr_accessor :parent, :synchronized
 	attr_reader :state, :model
 

data/lib/sfpagent/net_helper.rb

@@ -1,10 +1,10 @@
 require 'uri'
 require 'net/http'
 
-module Nuri::Net
+module Sfp::Net
 end
 
-module Nuri::Net::Helper
+module Sfp::Net::Helper
 	def http_request(uri, request, open_timeout=5, read_timeout=1800)
 		http = Net::HTTP.new(uri.host, uri.port)
 		http.open_timeout = open_timeout

data/lib/sfpagent/sfplanner.rb

@@ -1,85 +1,217 @@
-module Planner
-	def initialize(sas)
+#!/usr/bin/env ruby
+
+class Planner
+	def initialize(p={})
 		# TODO
 		# - build from SAS string
-		# - generate image dependencies and joins graph
+		# - generate image dependencies and joints graph
+
+		@vars = []
+		@variables = {}
+		@ops = []
+		@operators = {}
+		@init = @goal = nil
+
+		lines = p[:sas].split("\n")
+		i = 0
+		while i < lines.length
+			if lines[i] == 'begin_variable'
+				i, var = Variable.read(i, lines)
+				@vars << var
+				@variables[var.sym] = var
+			elsif lines[i] == 'begin_operator'
+				i, op = Operator.read(i, lines, @vars)
+				@ops << op
+				@operators[op.sym] = op
+			elsif lines[i] == 'begin_state'
+				i, @init = State.read(i, lines, @vars)
+			elsif lines[i] == 'begin_goal'
+				i, @goal = State.read(i, lines, @vars)
+			end
+			i += 1
+		end
+
+		@ops.each { |op| op.update_variables_joints_and_dependencies(@variables) }
+
+		puts "#{@vars.length} variables"
+		puts "#{@ops.length} operators"
+		puts "#{@init.length} initial state"
+		puts "#{@goal.length} goal state"
+
+		@vars.each { |v|
+			puts v.to_s
+			if v.dependencies.length > 0
+				print "\tdep|"
+				v.dependencies.each { |k,v| print "#{k}:#{v.length}|" }
+				puts ''
+			end
+			if v.joints.length > 0
+				print "\tjoint|"
+				v.joints.each { |k,v| print "#{k}:#{v.length}|" }
+				puts ''
+			end
+		}
+		@ops.each { |op| puts op.inspect }
+		puts @init.inspect
+		puts @goal.inspect
+	end
+
+	def to_image(p={})
 	end
 
 	class Variable < Array
-		attr_accessor :init, :goal, :joins, :dependencies
-		attr_reader :name
+		attr_reader :name, :sym
+		attr_accessor :init, :goal, :joints, :dependencies
+
+		def self.read(i, lines)
+			var = Variable.new(lines[i+1])
+			i += 4
+			i.upto(lines.length) do |j|
+				i = j
+				break if lines[j] == 'end_variable'
+				var << lines[j].to_sym
+			end
+			fail "Cannot find end_variable" if lines[i] != 'end_variable'
+			[i, var]
+		end
 	
 		def initialize(name, init=nil, goal=nil)
 			@name = name
+			@sym = @name.to_sym
 			@values = []
 			@map = {}
 			@init = init
 			@goal = goal
-			@joins = {}
+			@joints = {}
 			@dependencies = {}
 		end
+
+		alias :super_to_s :to_s
+		def to_s
+			@name + " " + super_to_s
+		end
 	end
 	
 	class Operator
-		attr_reader :name, :cost, :preconditions, :postconditions, :variables
+		attr_reader :name, :sym
+		attr_accessor :cost, :preconditions, :postconditions, :variables
+
+		def self.read(i, lines, variables)
+			op = Operator.new(lines[i+1])
+			i += 2
+			last = nil
+			i.upto(lines.length) do |j|
+				i = j
+				break if lines[j] == 'end_operator'
+				parts = lines[j].split(' ')
+				if parts.length > 1
+					var = variables[parts[1].to_i]
+					pre = (parts[2] == '-1' ? nil : var[parts[2].to_i])
+					post = (parts[3].nil? ? nil : var[parts[3].to_i])
+					op.param var, pre, post
+				end
+				last = lines[j]
+			end
+			op.cost = last.to_i
+			fail "Cannot find end_operator" if lines[i] != 'end_operator'
+			[i, op]
+		end
 	
 		def initialize(name, cost=1)
 			@name = name
+			@sym = @name.to_sym
 			@cost = cost
 			@preconditions = {}
 			@postconditions = {}
 			@variables = {}
 		end
 	
-		def <<(variable, pre=nil, post=nil)
+		def param(variable, pre=nil, post=nil)
 			return if variable.nil? or (pre.nil? and post.nil?)
 			if !pre.nil?
 				fail "Invalid precondition #{variable.name}:#{pre}" if !variable.index(pre)
-				@preconditions[variable] = pre
+				@preconditions[variable.sym] = pre
 			end
 			if !post.nil?
 				fail "Invalid postcondition #{variable.name}:#{post}" if !variable.index(post)
-				@postconditions[variable] = post
+				@postconditions[variable.sym] = post
 			end
-			@variables[variable.name] = variable
+			@variables[variable.sym] = variable
 		end
 	
 		def applicable(state)
-			@preconditions.each { |var,pre| return false if state[var] != pre }
+			@preconditions.each { |var,pre| return false if state[var.sym] != pre }
 			true
 		end
 	
 		def apply(state)
-			@postconditions.each { |var,post| state[var] = post }
+			@postconditions.each { |var,post| state[var.sym] = post }
 		end
 
-		def update_joins_and_dependencies
-			@postconditions.each_key { |var_post|
-				@preconditions.each_key { |var_pre|
-					next if var_post == var_pre
-					if !var_post.dependencies.has_key?(var_pre)
-						var_post.dependencies[var_pre] = [self]
+		def update_variables_joints_and_dependencies(variables)
+			@postconditions.each_key { |post|
+				var_post = variables[post]
+				@preconditions.each_key { |pre|
+					next if post == pre
+					var_pre = variables[pre]
+					if !var_post.dependencies.has_key?(pre)
+						var_post.dependencies[pre] = [self]
 					else
-						var_post.dependencies[var_pre] << self
+						var_post.dependencies[pre] << self
 					end
 				}
-				@postconditions.each_key { |var_post2|
-					next if var_post == var_post2
-					if !var_post.joins.has_key?(var_post2)
-						var_post.joins[var_post2] = [self]
+				@postconditions.each_key { |post2|
+					next if post == post2
+					var_post2 = variables[post2]
+					if !var_post.joints.has_key?(post2)
+						var_post.joints[post2] = [self]
 					else
-						var_post.joins[var_post2] << self
+						var_post.joints[post2] << self
 					end
 				}
 			}
 		end
+
+		def to_s
+			@name + " pre:" + @preconditions.inspect + " post:" + @postconditions.inspect
+		end
 	end
 	
 	class State < Hash
 		attr_reader :id
-	
+
+		def self.read(i, lines, variables)
+			state = State.new(lines[i] == 'begin_state' ? 'init' : 'goal')
+			if state.id == 'init'
+				i += 1
+				var_index = 0
+				i.upto(lines.length) do |j|
+					i = j
+					break if lines[j] == 'end_state'
+					var = variables[var_index]
+					state[var.sym] = var[lines[j].to_i]
+					var_index += 1
+				end
+				fail "Cannot find end_state" if lines[i] != 'end_state'
+				[i, state]
+			elsif state.id == 'goal'
+				i += 2
+				i.upto(lines.length) do |j|
+					i = j
+					break if lines[j] == 'end_goal'
+					parts = lines[j].split(' ')
+					var = variables[parts[0].to_i]
+					state[var.sym] = var[parts[1].to_i]
+				end
+				fail "Cannot find end_goal" if lines[i] != 'end_goal'
+				[i, state]
+			end
+		end
+
 		def initialize(id)
 			@id = id
 		end
 	end
 end
+
+Planner.new(:sas => File.read(ARGV[0]))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sfpagent
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2013-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sfp
-  requirement: &6605340 !ruby/object:Gem::Requirement
+  requirement: &13903480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 0.3.12
   type: :runtime
   prerelease: false
-  version_requirements: *6605340
+  version_requirements: *13903480
 description: A Ruby implementation of SFP agent.
 email: herry13@gmail.com
 executables:
@@ -34,6 +34,7 @@ files:
 - README.md
 - VERSION
 - bin/cert.rb
+- bin/install_module
 - bin/sfpagent
 - lib/sfpagent.rb
 - lib/sfpagent/agent.rb