sfpagent 0.1.6 → 0.1.9

data/lib/sfpagent/bsig.rb

@@ -1,22 +1,311 @@
-module Sfp::BSig
-end
+require 'thread'
+
+class Sfp::BSig
+	include Nuri::Net::Helper
+
+	BSigSleepTime = 5
+	MaxTries = 5
+
+	SatisfierPath = '/bsig/satisfier'
+	CachedDir = (Process.euid == 0 ? '/var/sfpagent' : File.expand_path('~/.sfpagent'))
+	SatisfierLockFile = CachedDir + '/bsig.satisfier.lock'
+
+	attr_accessor :enabled, :mode
+
+	def initialize
+		@lock = Mutex.new
+		@enabled = false
+	end
+
+	def disable
+		@enabled = false
+	end
+
+	def enable(p={})
+		@lock.synchronize {
+			return if @enabled
+			@enabled = true
+		}
+
+		if p[:mode] == :main
+			enable_main_thread
+		elsif p[:mode] == :satisfier
+			enable_satisfier_thread
+		end
+	end
+
+	def enable_satisfier_thread
+		@mode = :satisfier
+		Sfp::Agent.logger.info "[satisfier] BSig engine is enabled."
+	end
+
+	def enable_main_thread
+		@mode = :main
+
+		['INT', 'KILL', 'HUP'].each { |signal|
+			trap(signal) {
+				Sfp::Agent.logger.info "Shutting down BSig engine"
+				disable
+			}
+		}
+		register_satisfier_thread(:reset)
+
+		Sfp::Agent.logger.info "[main] BSig engine is running."
+
+		puts "BSig Engine is running with PID #{$$}"
+		File.open(Sfp::Agent::BSigPIDFile, 'w') { |f| f.write($$.to_s) }
+
+		self.execute_model
+
+		Sfp::Agent.logger.info "[main] BSig engine has stopped."
+	end
 
-module Sfp::BSig::Main
 	def execute_model
-		# TODO -- implement
+		while @enabled
+			begin
+				Sfp::Agent.logger.info "[main] Sfp::BSig enabled"
+	
+				wait_for_satisfier?
+	
+				bsig = Sfp::Agent.get_bsig
+				if bsig.nil?
+					sleep BSigSleepTime
+				else
+					status = achieve_local_goal(bsig['id'], bsig['goal'], bsig['operators'], 1, :main)
+Sfp::Agent.logger.info "[main] execute model - status: " + status.to_s
+					if status == :failure
+						Sfp::Agent.logger.error "[main] Executing BSig model [Failed]"
+						sleep BSigSleepTime
+					elsif status == :no_flaw
+						sleep BSigSleepTime
+					end
+				end
+			rescue Exception => e
+				Sfp::Agent.logger.error "Error on executing BSig model\n#{e}\n#{e.backtrace.join("\n")}"
+				sleep BSigSleepTime
+			end
+		end
 	end
 
-	def achieve_local_goals(version, goals, operators, pi)
-		# TODO -- implement
+	def wait_for_satisfier?
+		total_satisfier = 1
+		loop do
+			total_satisfier = (File.exist?(SatisfierLockFile) ? File.read(SatisfierLockFile).to_i : 0)
+			return if total_satisfier <= 0
+			sleep 1
+		end
 	end
 
-	def achieve_remote_goals(version, goals, pi)
-		# TODO -- implement
+	# returns
+	# :no_flaw   : there is no goal-flaw
+	# :failure   : there is a failure on achieving the goal
+	# :ongoing   : the selected operator is being executed
+	# :repaired  : some goal-flaws have been repaired, but the goal may have other flaws
+	def achieve_local_goal(id, goal, operators, pi, mode=nil)
+		operator = nil
+
+		current = get_current_state
+		flaws = compute_flaws(goal, current)
+		return :no_flaw if flaws.length <= 0
+Sfp::Agent.logger.info "[#{mode}] Flaws: #{JSON.generate(flaws)}"
+
+		operator = select_operator(flaws, operators, pi)
+		return :failure if operator.nil?
+
+		@lock.synchronize {
+			return :ongoing if operator['selected']
+			operator['selected'] = true
+Sfp::Agent.logger.info "[#{mode}] Selected operator: #{JSON.generate(operator)}"
+		}
+
+		next_pi = pi + 1
+		pre_local, pre_remote = split_preconditions(operator)
+
+Sfp::Agent.logger.info "[#{mode}] local-flaws: #{JSON.generate(pre_local)}"
+Sfp::Agent.logger.info "[#{mode}] remote-flaws: #{JSON.generate(pre_remote)}"
+
+		status = nil
+		tries = MaxTries
+		begin
+			status = achieve_local_goal(id, pre_local, operators, next_pi)
+			if status == :no_flaw or status == :failure or not @enabled
+				break
+			elsif status == :ongoing
+				sleep BSigSleepTime
+				tries += 1
+			elsif status == :repaired
+				tries = MaxTries
+			end
+			tries -= 1
+		end until tries <= 0
+
+#Sfp::Agent.logger.info "[#{mode}] status local: " + status.to_s
+		return :failure if status == :failure
+
+		return :failure if not achieve_remote_goal(id, pre_remote, next_pi)
+
+		return :failure if not invoke(operator)
+		
+		:repaired
+
+	ensure
+		@lock.synchronize { operator['selected'] = false } if not operator.nil?
+	end
+
+	def achieve_remote_goal(id, goal, pi)
+		if goal.length > 0
+			agents = Sfp::Agent.get_agents
+			split_goal_by_agent(goal).each do |agent,g|
+				return false if not agents.has_key?(agent) or agents[agent]['sfpAddress'].to_s == ''
+				return false if not send_goal_to_agent(agents[agent], id, g, pi)
+			end
+		end
+		true
+	end
+
+	def receive_goal_from_agent(id, goal, pi)
+		register_satisfier_thread
+
+Sfp::Agent.logger.info "[satisfier] enabled: " + @enabled.to_s
+		return false if not @enabled
+
+		bsig = Sfp::Agent.get_bsig
+
+Sfp::Agent.logger.info "[satisfier] receive_goal_from_agent - " + id.inspect + " - " + goal.inspect + " - " + pi.inspect
+Sfp::Agent.logger.info "[satisfier] " + bsig.inspect
+
+		return false if bsig.nil? or id < bsig['id']
+
+		status = nil
+		tries = MaxTries
+		begin
+			status = achieve_local_goal(bsig['id'], goal, bsig['operators'], pi, :satisfier)
+			if status == :no_flaw or status == :failure or not @enabled
+				break
+			elsif status == :ongoing
+				sleep BSigSleepTime
+				tries += 1
+			elsif status == :repaired
+				tries = MaxTries
+			end
+			tries -= 1
+		end until tries <= 0
+
+		return false if status == :failure
+
+		true
+
+	ensure
+		unregister_satisfier_thread
+	end
+
+	protected
+	def register_satisfier_thread(mode=nil)
+		return if mode == :reset and File.exist?(SatisfierLockFile)
+
+		File.open(SatisfierLockFile, File::RDWR|File::CREAT, 0644) { |f|
+			f.flock(File::LOCK_EX)
+			value = (mode == :reset ? 0 : (f.read.to_i + 1))
+			f.rewind
+			f.write(value.to_s)
+			f.flush
+			f.truncate(f.pos)
+		}
+	end
+
+	def unregister_satisfier_thread
+		File.open(SatisfierLockFile, File::RDWR|File::CREAT, 0644) { |f|
+			f.flock(File::LOCK_EX)
+			value = f.read.to_i - 1
+			f.rewind
+			f.write(value.to_s)
+			f.flush
+			f.truncate(f.pos)
+		}
+	end
+
+	def split_goal_by_agent(goal)
+		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)
+			agent_goal[agent_name] = {} if not agent_goal.has_key?(agent_name)
+			agent_goal[agent_name][var] = val
+		}
+		agent_goal
+	end
+
+	def send_goal_to_agent(agent, id, g, pi)
+		data = {'id' => id,
+		        'goal' => JSON.generate(g),
+		        'pi' => pi}
+		code, _ = put_data(agent['sfpAddress'], agent['sfpPort'], SatisfierPath, data)
+Sfp::Agent.logger.info "send_goal_to_agent - status: " + code.to_s
+		(code == '200')
+	end
+
+	def get_current_state
+		state = Sfp::Agent.get_state
+		fail "BSig engine cannot get current state" if state == false
+		state
+	end
+
+	def compute_flaws(goal, current)
+		return goal.clone if current.nil?
+		flaws = {}
+		goal.each { |var,val|
+			current_value = current.at?(var)
+			if current_value.is_a?(Sfp::Undefined)
+				flaws[var] = val if not val.is_a?(Sfp::Undefined)
+			else
+				current_value.sort! if current_value.is_a?(Array)
+				flaws[var]= val if current_value != val
+			end
+		}
+		flaws
+	end
+
+	def select_operator(flaws, operators, pi)
+		selected_operator = nil
+		operators.each { |op|
+			next if op['pi'] < pi
+			if can_repair?(op, flaws)
+				if selected_operator.nil?
+					selected_operator = op
+				elsif selected_operator['pi'] > op['pi']
+					selected_operator = op
+				end
+			end
+		}
+		selected_operator
+	end
+
+	def can_repair?(operator, flaws)
+		operator['effect'].each { |var,val|
+			return true if flaws[var] == val
+		}
+		false
+	end
+
+	def split_preconditions(operator)
+		local = {}
+		remote = {}
+		if not operator.nil?
+			myself = Sfp::Agent.whoami?
+			operator['condition'].each { |var,val|
+				_, agent_name, _ = var.split('.', 3)
+				if agent_name == myself
+					local[var] = val
+				else
+					remote[var] = val
+				end
+			}
+		end
+		[local, remote]
 	end
-end
 
-module Sfp::BSig::Satisfier
-	def receive_goals(agent, version, goals, pi)
-		# TODO -- implement
+	def invoke(operator)
+		Sfp::Agent.execute_action(operator)
 	end
 end

data/lib/sfpagent/module.rb

@@ -5,18 +5,22 @@ module Sfp::Resource
 	attr_accessor :parent, :synchronized
 	attr_reader :state, :model
 
-	def init(model, default)
+	def init(model={})
 		@model = {}
-		model.each { |k,v| @model[k] = v }
 		@state = {}
-		@default = {}
 		@synchronized = []
+
+		update_model(model)
 	end
 
 	def update_state
 		@state = {}
 	end
 
+	def update_model(model)
+		model.each { |k,v| @model[k] = v }
+	end
+
 	def apply(p={})
 		true
 	end

data/lib/sfpagent/runtime.rb

@@ -1,25 +1,31 @@
 require 'thread'
 
 class Sfp::Runtime
-	attr_reader :modules
+	attr_reader :root
 
 	def initialize(model)
 		@mutex_procedure = Mutex.new
-		@root = model
-		@modules = nil
+		@mutex_get_state = Mutex.new
+		@root = nil
+		set_model(model)
+	end
+
+	def whoami?
+		@model.each { |key,value| return key if key[0,1] != '_' and value['_context'] == 'object' } if !@model.nil?
+		nil
 	end
 
 	def execute_action(action)
+		return false if !defined?(@root) or @root.nil?
+
 		def normalise_parameters(params)
 			p = {}
 			params.each { |k,v| p[k[2,k.length-2]] = v }
 			p
 		end
 
-		self.get_state if not defined?(@modules) or @modules.nil?
-
 		module_path, method_name = action['name'].pop_ref
-		mod = @modules.at?(module_path)[:_self]
+		mod = @root.at?(module_path)[:_self]
 		raise Exception, "Module #{module_path} cannot be found!" if mod.nil?
 		raise Exception, "Cannot execute #{action['name']}!" if not mod.respond_to?(method_name)
 
@@ -33,102 +39,109 @@ class Sfp::Runtime
 		# TODO - check post-execution state for verification
 	end
 
+	def set_model(model)
+		@mutex_get_state.synchronize {
+			@model = model
+			if @model.is_a?(Hash)
+				root_model = Sfp::Helper.deep_clone(@model)
+				root_model.accept(SFPtoRubyValueConverter)
+				root_model.accept(ParentEliminator)
+				@root = update_model(root_model, root_model, '$')
+				@root.accept(ParentGenerator)
+			end
+		}
+	end
+
 	def get_state(as_sfp=false)
-		def cleanup(model)
-			model.select { |k,v| k[0,1] != '_' and !(v.is_a?(Hash) and v['_context'] != 'object') }
-		end
+		@mutex_get_state.synchronize {
+			update_state(@root)
+			get_object_state(@root, @model)
+		}
+	end
 
-		def add_hidden_attributes(model, state)
-			model.each { |k,v|
-				state[k] = v if (k[0,1] == '_' and k != '_parent') or
-					(v.is_a?(Hash) and v['_context'] == 'procedure')
-			}
+	protected
+	def get_object_state(object, model)
+		# get object's state
+		state = (object.has_key?(:_self) ? object[:_self].state : {})
+
+		# add hidden attributes and procedures
+		model.each { |k,v|
+			state[k] = v if (k[0,1] == '_' and k != '_parent') or
+				(v.is_a?(Hash) and v['_context'] == 'procedure')
+		}
+
+		# accumulate children's state
+		object.each { |name,child|
+			next if name.to_s[0,1] == '_'
+			state[name] = get_object_state(child, model[name])
+		}
+
+		# set state=Sfp::Undefined for each attribute that exists in the model
+		# but not covered by SFP object instants
+		(model.keys - state.keys).each do |name|
+			next if name[0,1] == '_'
+			state[name] = Sfp::Undefined.new
 		end
 
-		# Load the implementation of an object, and return its current state
-		# @param model a Hash
-		# @return a Hash which is the state of the object
-		#
-		def instantiate_module(model, root, as_sfp=false)
-			# extract class name
-			class_name = model['_isa'].sub(/^\$\./, '')
-
-			# throw an exception if schema's implementation is not exist!
-			raise Exception, "Implementation of schema #{class_name} is not available!" if
-				not Sfp::Module.const_defined?(class_name)
-
-			# create an instance of the schema
-			mod = Sfp::Module::const_get(class_name).new
-			default = cleanup(root.at?(model['_isa']))
-			ruby_model = cleanup(model)
-			mod.init(ruby_model, default)
-
-			# update synchronized list of procedures
-			model.each { |k,v|
-				next if k[0,1] == '_' or not (v.is_a?(Hash) and v['_context'] == 'procedure')
-				mod.synchronized << k if v['_synchronized']
-			}
-
-			# return the object instant
-			mod
-		end
+		state
+	end
 
-		# Return the state of an object
-		#
-		def get_object_state(model, root, as_sfp=false, path='$')
-			modules = {}
-			state = {}
-			if model['_context'] == 'object' and model['_isa'].to_s.isref
-				if model['_isa'] != '$.Object'
-					# if this model is an instance of a subclass of Object, then
-					# get the current state of this object
-					#modules[:_self] = nil
-					mod = (!defined?(@modules) or @modules.nil? ? nil : @modules.at?(path))
-					if mod.is_a?(Hash)
-						modules[:_self] = mod[:_self]
-					else
-						# the module has not been instantiated yet!
-						modules[:_self] = instantiate_module(model, root, as_sfp)
-					end
-					# update and get the state
-					modules[:_self].update_state
-					state = modules[:_self].state
-					if !mod.nil? and mod.has_key?(:_vars)
-						state.keep_if { |k,v| mod[:_vars].index(k) }
-						modules[:_vars] = mod[:_vars]
-					else
-						modules[:_vars] = state.keys
-					end
-					# set hidden attributes
-					add_hidden_attributes(model, state) if as_sfp
-				end
-			end
+	def update_state(object)
+		object[:_self].update_state if not object[:_self].nil?
+		object.each { |k,v| update_state(v) if k.to_s[0,1] != '_' }
+	end
 
-			# get the state for each attributes which are not covered by this
-			# object's module
-			(model.keys - state.keys).each do |key|
-				next if key[0,1] == '_'
-				if model[key].is_a?(Hash)
-					modules[key], state[key] = get_object_state(model[key], root, as_sfp, path.push(key)) if
-						model[key]['_context'] == 'object'
-					modules[key]['_parent'] = modules if modules[key].is_a?(Hash)
-				else
-					state[key] = Sfp::Undefined.new
-				end
+	def update_model(model, root, path)
+		object = {}
+		if model['_context'] == 'object' and model['_isa'].to_s.isref and model['_isa'].to_s != '$.Object'
+			# if this model is an instance of a subclass of Object, then
+			# get the current state of this object
+			obj = (!defined?(@root) or @root.nil? ? nil : @root.at?(path))
+			if obj.is_a?(Hash)
+				object[:_self] = obj[:_self]
+				object[:_self].update_model(model)
+			else
+Sfp::Agent.logger.info "Instantiating object: #{model['_self']}"
+				# the module has not been instantiated yet!
+				object[:_self] = instantiate_sfp_object(model, root)
 			end
+		end
 
-			[modules, state]
+		model.each do |key,child|
+			next if key[0,1] == '_' or not child.is_a?(Hash) or child['_context'] != 'object' or
+				child['_isa'].to_s == '$.Object'
+				#not child['_isa'].to_s.isref or child['_isa'].to_s == '$.Object'
+			object[key] = update_model(child, root, path.push(key))
 		end
 
-		root = Sfp::Helper.deep_clone(@root)
-		root.accept(ParentEliminator)
-		@modules, state = get_object_state(root, root, as_sfp)
-		@modules.accept(ParentGenerator)
+		object
+	end
 
-		state
+	def instantiate_sfp_object(model, root)
+		# get SFP schema name
+		schema_name = model['_isa'].sub(/^\$\./, '')
+
+		# throw an exception if schema's implementation is not exist!
+		raise Exception, "Implementation of schema #{schema_name} is not available!" if
+			not Sfp::Module.const_defined?(schema_name)
+
+		# create an instance of the schema
+		object = Sfp::Module::const_get(schema_name).new
+
+		# initialize the instance
+		object_model = model.select { |k,v| k[0,1] != '_' and
+			not (v.is_a?(Hash) and v['_context'] == 'procedure') }
+		object.init(model)
+		
+		# update list of synchronized procedures
+		model.each { |k,v|
+			next if k[0,1] == '_' or not (v.is_a?(Hash) and v['_context'] == 'procedure')
+			object.synchronized << k if v['_synchronized']
+		}
+
+		object
 	end
 
-	protected
 	ParentEliminator = Sfp::Visitor::ParentEliminator.new
 
 	ParentGenerator = Object.new
@@ -137,4 +150,15 @@ class Sfp::Runtime
 		true
 	end
 
+	SFPtoRubyValueConverter = Object.new
+	def SFPtoRubyValueConverter.visit(name, value, parent)
+		if name[0,1] != '_' and value.is_a?(Hash)
+			if value['_context'] == 'null'
+				parent[name] = nil
+			elsif value['_context'] == 'set'
+				parent[name] = value['_values']
+			end
+		end
+		true
+	end
 end

data/lib/sfpagent/sfplanner.rb

@@ -0,0 +1,85 @@
+module Planner
+	def initialize(sas)
+		# TODO
+		# - build from SAS string
+		# - generate image dependencies and joins graph
+	end
+
+	class Variable < Array
+		attr_accessor :init, :goal, :joins, :dependencies
+		attr_reader :name
+	
+		def initialize(name, init=nil, goal=nil)
+			@name = name
+			@values = []
+			@map = {}
+			@init = init
+			@goal = goal
+			@joins = {}
+			@dependencies = {}
+		end
+	end
+	
+	class Operator
+		attr_reader :name, :cost, :preconditions, :postconditions, :variables
+	
+		def initialize(name, cost=1)
+			@name = name
+			@cost = cost
+			@preconditions = {}
+			@postconditions = {}
+			@variables = {}
+		end
+	
+		def <<(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
+			end
+			if !post.nil?
+				fail "Invalid postcondition #{variable.name}:#{post}" if !variable.index(post)
+				@postconditions[variable] = post
+			end
+			@variables[variable.name] = variable
+		end
+	
+		def applicable(state)
+			@preconditions.each { |var,pre| return false if state[var] != pre }
+			true
+		end
+	
+		def apply(state)
+			@postconditions.each { |var,post| state[var] = 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]
+					else
+						var_post.dependencies[var_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]
+					else
+						var_post.joins[var_post2] << self
+					end
+				}
+			}
+		end
+	end
+	
+	class State < Hash
+		attr_reader :id
+	
+		def initialize(id)
+			@id = id
+		end
+	end
+end

data/lib/sfpagent.rb

@@ -15,4 +15,5 @@ libdir = File.expand_path(File.dirname(__FILE__))
 require libdir + '/sfpagent/net_helper.rb'
 require libdir + '/sfpagent/runtime.rb'
 require libdir + '/sfpagent/module.rb'
+require libdir + '/sfpagent/bsig.rb'
 require libdir + '/sfpagent/agent.rb'

data/sfpagent.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new do |s|
 	s.homepage		= 'https://github.com/herry13/sfpagent'
 	s.rubyforge_project = 'sfpagent'
 
-	s.add_dependency 'sfp', '~> 0.3.9'
+	s.add_dependency 'sfp', '~> 0.3.12'
 end