sfpagent 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+*.swp

data/README.md

@@ -0,0 +1,22 @@
+SFP Agent for Ruby
+==================
+- Author: Herry (herry13@gmail.com)
+- Version: 0.0.1
+- License: [BSD License](https://github.com/herry13/sfp-ruby/blob/master/LICENSE)
+
+A gem that provides a Ruby interface to an SFP agent.
+
+
+To install
+----------
+
+	$ gem install sfpagent
+
+
+Requirements
+------------
+- Ruby (>= 1.8.7)
+- Rubygems
+	- sfp (>= 0.3.0)
+	- antlr3
+	- json

data/bin/cert.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'openssl'
+ 
+key = OpenSSL::PKey::RSA.new(1024)
+public_key = key.public_key
+ 
+subject = "/C=BE/O=Test/OU=Test/CN=Test"
+ 
+cert = OpenSSL::X509::Certificate.new
+cert.subject = cert.issuer = OpenSSL::X509::Name.parse(subject)
+cert.not_before = Time.now
+cert.not_after = Time.now + 365 * 24 * 60 * 60
+cert.public_key = public_key
+cert.serial = 0x0
+cert.version = 2
+ 
+ef = OpenSSL::X509::ExtensionFactory.new
+ef.subject_certificate = cert
+ef.issuer_certificate = cert
+cert.extensions = [
+  ef.create_extension("basicConstraints","CA:TRUE", true),
+  ef.create_extension("subjectKeyIdentifier", "hash"),
+  # ef.create_extension("keyUsage", "cRLSign,keyCertSign", true),
+]
+cert.add_extension ef.create_extension("authorityKeyIdentifier",
+                                       "keyid:always,issuer:always")
+ 
+cert.sign key, OpenSSL::Digest::SHA1.new
+
+if ARGV.length < 3
+	puts cert.to_pem
+	puts key.to_pem
+	puts public_key.to_pem
+else
+	File.open(ARGV[0], 'w') { |f| f.write(cert.to_pem) }
+	File.open(ARGV[1], 'w') { |f| f.write(key.to_pem) }
+	File.open(ARGV[2], 'w') { |f| f.write(public_key.to_pem) }
+end

data/bin/sfpagent

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+libdir = File.expand_path(File.dirname(__FILE__))
+require "#{libdir}/../lib/sfpagent"
+
+opts = Trollop::options do
+	version "sfpagent 0.0.1 (c) 2013 Herry"
+	banner <<-EOS
+SFP Agent that provides a Ruby framework for managing system configurations. The configurations are modelled in SFP language.
+
+Usage:
+       sfpagent [options] [model-file] [plan-file]
+
+where [options] are:
+EOS
+
+	opt :start, "Start the agent. If --daemon option is set true, then the agent will start as a daemon."
+	opt :stop, "Stop the daemon agent."
+	opt :status, "Print the status of the daemon agent."
+	opt :state, "Given a model, print the state of all modules. (Note: [model-file] should be specified.)"
+	opt :execute, "Given a model, execute a plan in given file. (Note: [model-file] should be specified.)"
+	opt :pretty, "Print the result in a pretty JSON format."
+	opt :port, "Port number of the daemon agent should listen to.", :default => Sfp::Agent::DefaultPort
+	opt :daemon, "Start the agent as a daemon.", :default => true
+	opt :ssl, "Set the agent to use HTTPS instead of HTTP.", :default => false
+	opt :certfile, "Certificate file for HTTPS.", :default => ''
+	opt :keyfile, "Private key file for HTTPS.", :default => ''
+	opt :modules_dir, "A directory that holds all SFP modules.", :default => ''
+end
+
+def parse(filepath)
+	home_dir = File.expand_path(File.dirname(filepath))
+	parser = Sfp::Parser.new({:home_dir => home_dir})
+	parser.parse(File.read(filepath))
+	parser
+end
+
+model_file = ARGV[0].to_s
+plan_file = ARGV[1].to_s
+
+if opts[:start]
+	Sfp::Agent.start(opts)
+
+elsif opts[:stop]
+	Sfp::Agent.stop
+
+elsif opts[:status]
+	Sfp::Agent.status
+
+elsif opts[:state]
+	abort "[model-file] is not specified!\nUse \"sfpagent -h\" for more details.\n" if model_file == ''
+	abort "File #{model_file} is not exist!" if not File.exist?(model_file)
+
+	opts[:daemon] = false
+	opts = Sfp::Agent.check_config(opts)
+	Sfp::Agent.load_modules(opts)
+	state = Sfp::Runtime.new(parse(model_file)).get_state(true)
+	puts JSON.pretty_generate(state)
+
+elsif opts[:execute]
+	abort "[model-file] is not specified!\nUse \"sfpagent -h\" for more details.\n" if model_file == ''
+	abort "[plan-file] is not specified!\nUse \"sfpagent -h\" for more details.\n" if plan_file == ''
+	abort "File #{model_file} is not exist!" if not File.exist?(model_file)
+	abort "File #{plan_file} is not exist!" if not File.exist?(plan_file)
+
+	opts[:daemon] = false
+	opts = Sfp::Agent.check_config(opts)
+	Sfp::Agent.load_modules(opts)
+	runtime = Sfp::Runtime.new(parse(model_file))
+	runtime.get_state
+	puts (runtime.execute_plan(File.read(plan_file)) ? "Success!" : "Failed!")
+
+else
+	Trollop::help
+
+end

data/lib/sfpagent/agent.rb

@@ -0,0 +1,590 @@
+require 'rubygems'
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+require 'thread'
+require 'uri'
+require 'net/http'
+require 'logger'
+
+module Sfp
+	module Agent
+		if Process.euid == 0
+			CachedDir = '/var/sfpagent'
+		else
+			CachedDir = File.expand_path('~/.sfpagent')
+		end
+		Dir.mkdir(CachedDir, 0700) if not File.exist?(CachedDir)
+
+		DefaultPort = 1314
+		PIDFile = "#{CachedDir}/sfpagent.pid"
+		LogFile = "#{CachedDir}/sfpagent.log"
+		ModelFile = "#{CachedDir}/sfpagent.model"
+		AgentsDataFile = "#{CachedDir}/sfpagent.agents"
+
+		@@logger = WEBrick::Log.new(LogFile, WEBrick::BasicLog::INFO ||
+		                                     WEBrick::BasicLog::ERROR ||
+		                                     WEBrick::BasicLog::FATAL ||
+		                                     WEBrick::BasicLog::WARN)
+
+		@@model_lock = Mutex.new
+
+		def self.logger
+			@@logger
+		end
+
+		def self.check_config(p={})
+			# check modules directory, and create it if it's not exist
+			p[:modules_dir] = "#{CachedDir}/modules" if p[:modules_dir].to_s.strip == ''
+			p[:modules_dir] = File.expand_path(p[:modules_dir].to_s)
+			p[:modules_dir].chop! if p[:modules_dir][-1,1] == '/'
+			Dir.mkdir(p[:modules_dir], 0700) if not File.exists?(p[:modules_dir])
+			p
+		end
+
+		# Start the agent.
+		#
+		# options:
+		#	:daemon => true if running as a daemon, false if as a normal application
+		#	:port
+		#	:ssl
+		#	:certfile
+		#	:keyfile
+		#
+		def self.start(p={})
+			begin
+				@@config = p = check_config(p)
+	
+				server_type = (p[:daemon] ? WEBrick::Daemon : WEBrick::SimpleServer)
+				port = (p[:port] ? p[:port] : DefaultPort)
+	
+				config = {:Host => '0.0.0.0', :Port => port, :ServerType => server_type,
+				          :Logger => @@logger}
+				if p[:ssl]
+					config[:SSLEnable] = true
+					config[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_NONE
+					config[:SSLCertificate] = OpenSSL::X509::Certificate.new(File.open(p[:certfile]).read)
+					config[:SSLPrivateKey] = OpenSSL::PKey::RSA.new(File.open(p[:keyfile]).read)
+					config[:SSLCertName] = [["CN", WEBrick::Utils::getservername]]
+				end
+
+				load_modules(p)
+				reload_model
+
+				server = WEBrick::HTTPServer.new(config)
+				server.mount("/", Sfp::Agent::Handler, @@logger)
+
+				fork {
+					begin
+						# send request to save PID
+						sleep 2
+						url = URI.parse("http://127.0.0.1:#{config[:Port]}/pid")
+						http = Net::HTTP.new(url.host, url.port)
+						if p[:ssl]
+							http.use_ssl = p[:ssl]
+							http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+						end
+						req = Net::HTTP::Get.new(url.path)
+						http.request(req)
+						puts "\nSFP Agent is running with PID #{File.read(PIDFile)}" if File.exist?(PIDFile)
+					rescue Exception => e
+						Sfp::Agent.logger.warn "Cannot request /pid #{e}"
+					end
+				}
+
+				trap('INT') { server.shutdown }
+
+				server.start
+			rescue Exception => e
+				@@logger.error "Starting the agent [Failed] #{e}"
+				raise e
+			end
+		end
+
+		# Stop the agent's daemon.
+		#
+		def self.stop
+			pid = (File.exist?(PIDFile) ? File.read(PIDFile).to_i : nil)
+			if not pid.nil? and `ps h #{pid}`.strip =~ /.*sfpagent.*/
+				print "Stopping SFP Agent with PID #{pid} "
+				Process.kill('KILL', pid)
+				puts "[OK]"
+				@@logger.info "SFP Agent daemon has been stopped."
+			else
+				puts "SFP Agent is not running."
+			end
+			File.delete(PIDFile) if File.exist?(PIDFile)
+		end
+
+		# Print the status of the agent.
+		#
+		def self.status
+			pid = (File.exist?(PIDFile) ? File.read(PIDFile).to_i : nil)
+			if pid.nil?
+				puts "SFP Agent is not running."
+			else
+				if `ps hf #{pid}`.strip =~ /.*sfpagent.*/
+					puts "SFP Agent is running with PID #{pid}"
+				else
+					File.delete(PIDFile)
+					puts "SFP Agent is not running."
+				end
+			end
+		end
+
+		# Save given model to cached file, and then reload the model.
+		#
+		def self.set_model(model)
+			begin
+				@@model_lock.synchronize {
+					@@logger.info "Setting the model [Wait]"
+					File.open(ModelFile, 'w', 0600) { |f|
+						f.write(JSON.generate(model))
+						f.flush
+					}
+				}
+				reload_model
+				@@logger.info "Setting the model [OK]"
+				return true
+			rescue Exception => e
+				@@logger.error "Setting the model [Failed] #{e}"
+			end
+			false
+		end
+
+		# Return the model which is read from cached file.
+		#
+		def self.get_model
+			return nil if not File.exist?(ModelFile)
+			begin
+				@@model_lock.synchronize {
+					return JSON[File.read(ModelFile)]
+				}
+			rescue Exception => e
+				@@logger.error "Get the model [Failed] #{e}\n#{e.backtrace}"
+			end
+			false
+		end
+
+		# Reload the model from cached file.
+		#
+		def self.reload_model
+			model = get_model
+			if model.nil?
+				@@logger.info "There is no model in cache."
+			else
+				begin
+					@@runtime = Sfp::Runtime.new(model)
+					@@logger.info "Reloading the model in cache [OK]"
+				rescue Exception => e
+					@@logger.error "Reloading the model in cache [Failed] #{e}"
+				end
+			end
+		end
+
+		# Return the current state of the model.
+		#
+		def self.get_state(as_sfp=true)
+			return nil if !defined? @@runtime or @@runtime.nil?
+			begin
+				return @@runtime.get_state(as_sfp)
+			rescue Exception => e
+				@@logger.error "Get state [Failed] #{e}\n#{e.backtrace.join("\n")}"
+			end
+			false
+		end
+
+		# Execute an action
+		#
+		# @param action contains the action's schema.
+		#
+		def self.execute_action(action)
+			logger = (@@config[:daemon] ? @@logger : Logger.new(STDOUT))
+			begin
+				result = @@runtime.execute_action(action)
+				logger.info "Executing #{action['name']} " + (result ? "[OK]" : "[Failed]")
+				return result
+			rescue Exception => e
+				logger.info "Executing #{action['name']} [Failed] #{e}\n#{e.backtrace.join("\n")}"
+				logger.error "#{e}\n#{e.bracktrace.join("\n")}"
+			end
+			false
+		end
+
+		# Load all modules in given directory.
+		#
+		# options:
+		#	:dir => directory that holds all modules
+		#
+		def self.load_modules(p={})
+			dir = p[:modules_dir]
+
+			logger = @@logger # (p[:daemon] ? @@logger : Logger.new(STDOUT))
+			@@modules = []
+			counter = 0
+			if dir != '' and File.exist?(dir)
+				logger.info "Modules directory: #{dir}"
+				Dir.entries(dir).each { |name|
+					next if name == '.' or name == '..' or File.file?("#{dir}/#{name}")
+					module_file = "#{dir}/#{name}/#{name}.rb"
+					next if not File.exist?(module_file)
+					begin
+						load module_file #require module_file
+						logger.info "Loading module #{dir}/#{name} [OK]"
+						counter += 1
+						@@modules << name
+					rescue Exception => e
+						logger.warn "Loading module #{dir}/#{name} [Failed]\n#{e}"
+					end
+				}
+			end
+			logger.info "Successfully loading #{counter} modules."
+		end
+
+		def self.get_schemata(module_name)
+			dir = @@config[:modules_dir]
+
+			filepath = "#{dir}/#{module_name}/#{module_name}.sfp"
+			sfp = parse(filepath).root
+			sfp.accept(Sfp::Visitor::ParentEliminator.new)
+			JSON.generate(sfp)
+		end
+
+		def self.get_module_hash(name)
+			return nil if @@config[:modules_dir].to_s == ''
+
+			module_dir = "#{@@config[: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
+
+		def self.get_modules
+			return [] if not (defined? @@modules and @@modules.is_a? Array)
+			data = {}
+			@@modules.each { |m| data[m] = get_module_hash(m) }
+			data
+			#(defined?(@@modules) and @@modules.is_a?(Array) ? @@modules : [])
+		end
+
+		def self.uninstall_all_modules(p={})
+			return true if @@config[:modules_dir] == ''
+			if system("rm -rf #{@@config[:modules_dir]}/*")
+				load_modules(@@config)
+				@@logger.info "Deleting all modules [OK]"
+				return true
+			end
+			@@logger.info "Deleting all modules [Failed]"
+			false
+		end
+
+		def self.uninstall_module(name)
+			return false if @@config[:modules_dir] == ''
+			
+			module_dir = "#{@@config[:modules_dir]}/#{name}"
+			if File.directory?(module_dir)
+				result = !!system("rm -rf #{module_dir}")
+			else
+				result = true
+			end
+			load_modules(@@config)
+			@@logger.info "Deleting module #{name} " + (result ? "[OK]" : "[Failed]")
+			result
+		end
+
+		def self.install_module(name, data)
+			return false if @@config[:modules_dir].to_s == ''
+
+			if !File.directory? @@config[:modules_dir]
+				File.delete @@config[:modules_dir] if File.exist? @@config[:modules_dir]
+				Dir.mkdir(@@config[:modules_dir], 0700)
+			end
+
+			# delete old files
+			module_dir = "#{@@config[:modules_dir]}/#{name}"
+			system("rm -rf #{module_dir}") if File.exist? module_dir
+
+			# save the archive
+			Dir.mkdir("#{module_dir}", 0700)
+			File.open("#{module_dir}/data.tgz", 'wb', 0600) { |f| f.syswrite data }
+
+			# extract the archive and the files
+			system("cd #{module_dir}; tar xvf data.tgz")
+			Dir.entries(module_dir).each { |name|
+				next if name == '.' or name == '..'
+				if File.directory? "#{module_dir}/#{name}"
+					system("cd #{module_dir}/#{name}; mv * ..; cd ..; rm -rf #{name}")
+				end
+				system("cd #{module_dir}; rm data.tgz")
+			}
+			load_modules(@@config)
+			@@logger.info "Installing module #{name} [OK]"
+
+			true
+		end
+
+		def self.get_log(n=0)
+			return '' if not File.exist?(LogFile)
+			if n <= 0
+				File.read(LogFile)
+			else
+				`tail -n #{n} #{LogFile}`
+			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?('address') or data['address'].to_s.strip == '' or
+						not data.has_key?('port')
+					buffer[name] = {}
+					buffer[name]['address'] = data['address'].to_s
+					buffer[name]['port'] = data['port'].to_s.strip.to_i
+					buffer[name]['port'] = DefaultPort if buffer[name]['port'] == 0
+				}
+				f.write(JSON.generate(buffer))
+				f.flush
+			end
+			true
+		end
+
+		def self.get_agents
+			return {} if not File.exist?(AgentsDataFile)
+			JSON[File.read(AgentsDataFile)]
+		end
+
+		# A class that handles each request.
+		#
+		class Handler < WEBrick::HTTPServlet::AbstractServlet
+			def initialize(server, logger)
+				@logger = logger
+			end
+
+			# Process HTTP Get request
+			#
+			# uri:
+			#	/pid => save daemon's PID to a file
+			#	/state => return the current state
+			#	/model => return the current model
+			#	/schemata => return the schemata of a module
+			#	/modules => return a list of available modules
+			#
+			def do_GET(request, response)
+				status = 400
+				content_type, body = ''
+				if not trusted(request.peeraddr[2])
+					status = 403
+				else
+					path = (request.path[-1,1] == '/' ? request.path.chop : request.path)
+					if path == '/pid' and (request.peeraddr[2] == 'localhost' or request.peeraddr[3] == '127.0.0.1')
+						status, content_type, body = save_pid
+
+					elsif path == '/state'
+						status, content_type, body = get_state
+
+					elsif path == '/sfpstate'
+						status, content_type, body = get_state({:as_sfp => true})
+
+					elsif path =~ /^\/state\/.+/
+						status, content_type, body = get_state({:path => path[7, path.length-7]})
+
+					elsif path =~ /^\/sfpstate\/.+/
+						status, content_type, body = get_state({:path => path[10, path.length-10]})
+
+					elsif path == '/model'
+						status, content_type, body = get_model
+
+					elsif path =~ /^\/schemata\/.+/
+						status, content_type, body = get_schemata({:module => path[10, path.length-10]})
+
+					elsif path == '/modules'
+						status, content_type, body = [200, 'application/json', JSON.generate(Sfp::Agent.get_modules)]
+
+					elsif path == '/log'
+						status, content_type, body = [200, 'text/plain', Sfp::Agent.get_log(100)]
+
+					end
+				end
+
+				response.status = status
+				response['Content-Type'] = content_type
+				response.body = body
+			end
+
+			# Handle HTTP Post request
+			#
+			# uri:
+			#	/execute => receive an action's schema and execute it
+			#
+			def do_POST(request, response)
+				status = 400
+				content_type, body = ''
+				if not self.trusted(request.peeraddr[2])
+					status = 403
+				else
+					path = (request.path[-1,1] == '/' ? ryyequest.path.chop : request.path)
+					if path == '/execute'
+						status, content_type, body = self.execute({:query => request.query})
+					end
+				end
+
+				response.status = status
+				response['Content-Type'] = content_type
+				response.body = body
+			end
+
+			# uri:
+			#	/model => receive a new model and save to cached file
+			#	/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
+			def do_PUT(request, response)
+				status = 400
+				content_type, body = ''
+				if not self.trusted(request.peeraddr[2])
+					status = 403
+				else
+					path = (request.path[-1,1] == '/' ? ryyequest.path.chop : request.path)
+
+					if path == '/model'
+						status, content_type, body = self.set_model({:query => request.query})
+
+					elsif path =~ /\/module\/.+/
+						status, content_type, body = self.manage_modules({:name => path[8, path.length-8],
+						                                                 :query => request.query})
+
+					elsif path =~ /\/modules\/.+/
+						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 == '/agents'
+						status, content_type, body = self.manage_agents({:query => request.query})
+
+					end
+				end
+
+				response.status = status
+				response['Content-Type'] = content_type
+				response.body = body
+			end
+
+			def manage_agents(p={})
+				begin
+					if p[:query].has_key?('agents')
+						return [200, '', ''] if Sfp::Agent.set_agents(JSON[p[:query]['agents']])
+					else
+						return [200, '', ''] if Sfp::Agent.set_agents({})
+					end
+				rescue Exception => e
+					@logger.error "Saving agents list [Failed]\n#{e}\n#{e.backtrace.join("\n")}"
+				end
+				[500, '', '']
+			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')
+						return [200, '', ''] if Sfp::Agent.install_module(p[:name], p[:query]['module'])
+					else
+						return [200, '', ''] if Sfp::Agent.uninstall_module(p[:name])
+					end
+				end
+				[500, '', '']
+			end
+
+			def get_schemata(p={})
+				begin
+					module_name, _ = p[:module].split('/', 2)
+					return [200, 'application/json', Sfp::Agent.get_schemata(module_name)]
+				rescue Exception => e
+					@logger.error "Sending schemata [Failed]\n#{e}"
+				end
+				[500, '', '']
+			end
+
+			def get_state(p={})
+				state = Sfp::Agent.get_state(!!p[:as_sfp])
+
+				# The model is not exist.
+				return [404, 'text/plain', 'There is no model!'] if state.nil?
+
+				if !!state
+					state = state.at?("$." + p[:path].gsub(/\//, '.')) if !!p[:path]
+					return [200, 'application/json', JSON.generate({'state'=>state})]
+				end
+
+				# There is an error when retrieving the state of the model!
+				[500, '', '']
+			end
+
+			def set_model(p={})
+				if p[:query].has_key?('model')
+					# Setting the model was success, and then return '200' status.
+					return [200, '', ''] if Sfp::Agent.set_model(JSON[p[:query]['model']])
+				else
+					# Remove the existing model by setting an empty model
+					return [200, '', ''] if Sfp::Agent.set_model({})
+				end
+
+				# There is an error on setting the model!
+				[500, '', '']
+			end
+
+			def get_model
+				model = Sfp::Agent.get_model
+
+				# The model is not exist.
+				return [404, '', ''] if model.nil?
+
+				# The model is exist, and then send the model in JSON.
+				return [200, 'application/json', JSON.generate(model)] if !!model
+
+				# There is an error when retrieving the model!
+				[500, '', '']
+			end
+
+			def execute(p={})
+				return [400, '', ''] if not p[:query].has_key?('action')
+				begin
+					return [200, '', ''] if Sfp::Agent.execute_action(JSON[p[:query]['action']])
+				rescue
+				end
+				[500, '', '']
+			end
+
+			def save_pid
+				begin
+					File.open(PIDFile, 'w', 0644) { |f| f.write($$.to_s) }
+					return [200, '', $$.to_s]
+				rescue Exception
+				end
+				[500, '', '']
+			end
+
+			def trusted(address)
+				true
+			end
+		end
+	end
+
+	def self.require(gem, pack=nil)
+		::Kernel.require gem
+	rescue LoadError => e
+		::Kernel.require gem if system("gem install #{pack||gem} --no-ri --no-rdoc")
+	end
+end

data/lib/sfpagent/executor.rb

@@ -0,0 +1,207 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'thread'
+
+module Sfp
+	module Executor
+		class ExecutionException < Exception; end
+		class ParallelExecutionException < Exception; end
+		class SequentialExecutionException < Exception; end
+
+		# @param :plan the plan to be executed
+		# @param :owner an object that implement the action
+		# @param :retry number of retries (default: 2) when execution is failed
+		#
+		def execute_plan(params={})
+			if params[:plan].nil? or not params[:plan].is_a?(Hash)
+				raise ExecutionException, 'Plan is not available.'
+			elsif params[:plan]['type'].to_s == 'parallel' or
+			      params[:plan][:type].to_s == 'parallel'
+				return self.execute_parallel_plan(params)
+			elsif params[:plan]['type'].to_s == 'sequential' or
+			      params[:plan][:type].to_s == 'sequential'
+				return self.execute_sequential_plan(params)
+			else
+				raise ExecutionException, 'Unknown type of plan!'
+			end
+			false
+		end
+
+		# @param :plan the plan to be executed
+		# @param :owner an object that implement the action
+		# @param :retry number of retries (default: 2) when execution is failed
+		#
+		def execute_parallel_plan(params={})
+			def assign_action_with_id(id)
+				thread_id = next_thread_id
+				action = @actions[id]
+				action[:executor] = thread_id
+				self.thread_execute_action(thread_id, action)
+			end
+
+			def next_thread_id
+				id = 0
+				@mutex.synchronize { @thread_id = id = @thread_id + 1 }
+				id
+			end
+
+			def action_to_string(action)
+				"#{action['id']}:#{action['name']}#{JSON.generate(action['parameters'])}"
+			end
+
+			def thread_execute_action(tid, action)
+				t = Thread.new {
+					@mutex.synchronize { @threads << tid }
+
+					while not @failed and not action[:executed]
+						# execute the action
+						op_str = action_to_string(action)
+						#Nuri::Util.puts "[ExecutorThread: #{tid}] #{op_str}"
+						success = false
+						num = @retry
+						begin
+							success = @owner.execute_action { action }
+							num -= 1
+						end while not success and num > 0
+
+						# check if execution failed
+						if success
+							next_actions = []
+							@mutex.synchronize {
+								# set executed
+								action[:executed] = true
+								# select next action to be executed from all predecessor actions
+								# if each action has not been assigned to any thread yet
+								if action['successors'].length > 0
+									action['successors'].each { |id|
+										if @actions[id][:executor].nil?
+											predecessors_ok = true
+											@actions[id]['predecessors'].each { |pid|
+												predecessors_ok = (predecessors_ok and @actions[pid][:executed])
+											}
+											next_actions << id if predecessors_ok
+										end
+									}
+								end
+								next_actions.each { |id| @actions[id][:executor] = tid }
+							}
+							if next_actions.length > 0
+								# execute next actions
+								action = @actions[next_actions[0]]
+								if next_actions.length > 1
+									for i in 1..(next_actions.length-1)
+										assign_action_with_id(next_actions[i])
+									end
+								end
+							end
+								
+						else
+							Nuri::Util.error "Failed executing #{op_str}!"
+							@mutex.synchronize {
+								@failed = true # set global flag
+								@actions_failed << action
+							}
+						end
+					end
+
+					@mutex.synchronize { @threads.delete(tid) }
+				}
+			end
+
+			if params[:plan].nil? or not params[:plan].is_a?(Hash)
+				raise ParallelExecutionException, 'Plan is not available.'
+			elsif params[:plan]['type'].to_s == 'parallel' or
+			      params[:plan][:type].to_s == 'parallel'
+			else
+				raise ParallelExecutionException, 'Not a parallel plan.'
+			end
+
+			@owner = params[:owner]
+			@retry = (params[:retry].nil? ? 2 : params[:retry].to_i)
+
+			@actions = params[:plan]['workflow']
+			@actions.sort! { |x,y| x['id'] <=> y['id'] }
+			@actions.each { |op| op[:executed] = false; op[:executor] = nil; }
+
+			@threads = []
+			@actions_failed = []
+			@mutex = Mutex.new
+			@failed = false
+			@thread_id = 0
+
+			params[:plan]['init'].each { |op_id| assign_action_with_id(op_id) }
+
+			begin
+				sleep 1
+			end while @threads.length > 0
+
+			Nuri::Util.log "Using #{@thread_id} threads in execution."
+
+			return (not @failed)
+		end
+
+		# @param :plan the plan to be executed
+		# @param :owner an object that implement the action
+		# @param :retry number of retries (default: 2) when execution is failed
+		#
+		def execute_sequential_plan(params={})
+			if params[:plan].nil? or not params[:plan].is_a?(Hash)
+				raise ParallelExecutionException, 'Plan is not available.'
+			elsif params[:plan]['type'].to_s == 'sequential' or
+			      params[:plan][:type].to_s == 'sequential'
+			else
+				raise ParallelExecutionException, 'Not a parallel plan.'
+			end
+
+			@owner = params[:owner]
+			@retry = (params[:retry].nil? ? 2 : params[:retry].to_i)
+			params[:plan]['workflow'].each { |action|
+				success = false
+				num = @retry
+				begin
+					success, data = @owner.execute_action { action }
+					puts data.to_s if params[:print_output]
+					num -= 1
+				end while not success and num > 0
+				return false if not success
+			}
+			true
+		end
+	end
+
+	class RubyExecutor
+		def execute_plan(params={})
+			exec = Object.new
+			exec.extend(Sfp::Executor)
+			params[:owner] = self
+			exec.execute_plan(params)
+		end
+
+		def execute_action
+			# TODO
+			action = yield
+			puts "Exec: #{action.inspect}"
+			[true, nil]
+		end
+	end
+
+	class BashExecutor < RubyExecutor
+		def execute_action
+			# TODO
+			action = yield
+			module_dir = (ENV.has_key?("SFP_HOME") ? ENV['SFP_HOME'] : ".")
+			script_path = "#{action['name'].sub!(/^\$\./, '')}"
+			script_path = "#{module_dir}/#{script_path.gsub!(/\./, '/')}"
+			cmd = "/bin/bash #{script_path}"
+			action['parameters'].each { |p| cmd += " '#{p}'" }
+			begin
+				data = `#{cmd}`
+			rescue Exception => exp
+				$stderr.puts "#{exp}\n#{exp.backtrace}"
+				[false, nil]
+			end
+			[true, data]
+		end
+	end
+end

data/lib/sfpagent/module.rb

@@ -0,0 +1,34 @@
+require 'etc'
+require 'fileutils'
+
+module Sfp::Resource
+	attr_reader :state, :model
+
+	def init(model, default)
+		@model = {}
+		model.each { |k,v| @model[k] = v }
+		@state = {}
+		@default = {}
+		#default.each { |k,v| @state[k] = @default[k] = v }
+	end
+
+	def update_state
+		@state = {}
+	end
+
+	def to_model
+		@state = {}
+		@model.each { |k,v| @state[k] = v }
+	end
+
+	alias_method :reset, :to_model
+
+	protected
+	def exec_seq(*commands)
+		commands = [commands.to_s] if not commands.is_a?(Array)
+		commands.each { |c| raise Exception, "Cannot execute: #{c}" if !system(c) }
+	end
+end
+
+module Sfp::Module
+end

data/lib/sfpagent/runtime.rb

@@ -0,0 +1,246 @@
+class Sfp::Runtime
+	def initialize(parser)
+		@parser = parser
+		@root = @parser.root
+	end
+
+	def execute_action(action)
+		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
+
+		module_path, method_name = action['name'].pop_ref
+		mod = @modules.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)
+
+		params = normalise_parameters(action['parameters'])
+		mod.send method_name.to_sym, params
+	end
+
+	def get_state(as_sfp=false)
+		def cleanup(value)
+			#value.accept(SfpState.new)
+			#value
+			value.select { |k,v| k[0,1] != '_' and !(v.is_a?(Hash) and v['_context'] != 'object') }
+			#value.keys.each { |k| value[k] = cleanup(value[k]) if value[k].is_a?(Hash) }
+		end
+
+		# Load the implementation of an object, and return its current state
+		# @param value a Hash
+		# @return a Hash which is the state of the object
+		#
+		def get_module_state(value, root, as_sfp=false)
+			# extract class name
+			class_name = value['_isa'].sub(/^\$\./, '') # [2, value['_isa'].length]
+
+			# 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?(value['_isa']))
+			model = cleanup(value)
+			mod.init(model, default)
+
+			# update and get state
+			mod.update_state
+			state = mod.state
+
+			# insert all hidden attributes, except "_parent"
+			value.each do |k,v|
+				state[k] = v if (k[0,1] == '_' and k != '_parent') or
+					(v.is_a?(Hash) and v['_context'] == 'procedure')
+			end if as_sfp
+			[mod, state]
+		end
+
+		# Return the state of an object
+		#
+		def get_object_state(value, root, as_sfp=false)
+			modules = {}
+			state = {}
+			if value['_context'] == 'object' and value['_isa'].to_s.isref
+				if value['_isa'] != '$.Object'
+					# if this value is an instance of a subclass of Object, then
+					# get the current state of this object
+					modules[:_self], state = get_module_state(value, root, as_sfp)
+				end
+			end
+
+			# get the state for each attributes which are not covered by this
+			# object's module
+			(value.keys - state.keys).each { |key|
+				next if key[0,1] == '_'
+				if value[key].is_a?(Hash)
+					modules[key], state[key] = get_object_state(value[key], root, as_sfp) if value[key]['_context'] == 'object'
+				else
+					state[key] = Sfp::Undefined.new
+				end
+			}
+
+			[modules, state]
+		end
+
+		root = Sfp::Helper.deep_clone(@root)
+		root.accept(Sfp::Visitor::ParentEliminator.new)
+		@modules, state = get_object_state(root, root, as_sfp)
+
+		state
+	end
+
+	def execute_plan(plan)
+		plan = JSON[plan]
+		if plan['type'] == 'sequential'
+			execute_sequential_plan(plan)
+		else
+			raise Exception, "Not implemented yet!"
+		end
+	end
+
+	protected
+	class SfpState
+		def visit(name, value, parent)
+			parent.delete(name) if name[0,1] == '_' or
+				(value.is_a?(Hash) and value['_context'] != 'object')
+			true
+		end
+	end
+
+	def execute_sequential_plan(plan)
+		puts 'Execute a sequential plan...'
+
+		plan['workflow'].each_index { |index|
+			action = plan['workflow'][index]
+			print "#{index+1}) #{action['name']} "
+			if not execute_action(action)
+				puts '[Failed]'
+				return false
+			end
+			puts '[OK]'
+		}
+		true
+	end
+end
+
+=begin
+		def execute(plan)
+			plan = JSON.parse(plan)
+			if plan['type'] == 'sequential'
+				execute_sequential(plan)
+			else
+				execute_parallel(plan)
+			end
+		end
+
+
+		def execute_sequential(plan)
+			puts 'Execute a sequential plan...'
+
+			plan['workflow'].each_index { |index|
+				action = plan['workflow'][index]
+				print "#{index+1}) #{action['name']} "
+
+				module_path, method_name = action['name'].pop_ref
+				mod = @modules.at?(module_path)[:_self]
+				raise Exception, "Cannot execute #{action['name']}!" if not mod.respond_to?(method_name)
+				if not mod.send method_name.to_sym, normalise_parameters(action['parameters'])
+					puts '[Failed]'
+					return false
+				end
+
+				puts '[OK]'
+			}
+			true
+		end
+
+		def execute_parallel(plan)
+			# TODO
+			puts 'Execute a parallel plan...'
+			false
+		end
+=end
+
+=begin
+		def plan
+			# generate initial state
+			task = { 'initial' => Sfp::Helper.to_state('initial', self.get_state(true)) }
+
+			# add schemas
+			@root.each { |k,v|
+				next if !v.is_a?(Hash) or v['_context'] != 'class'
+				task[k] = v
+			}
+
+			# add goal constraint
+			model = @root.select { |k,v| v.is_a?(Hash) and v['_context'] == 'object' }
+			goalgen = Sfp::Helper::GoalGenerator.new
+			model.accept(goalgen)
+			task['goal'] = goalgen.results
+
+			# remove old parent links
+			task.accept(Sfp::Visitor::ParentEliminator.new)
+
+			# reconstruct Sfp parent links
+			task.accept(Sfp::Visitor::SfpGenerator.new(task))
+
+			# solve and return the plan solution
+			planner = Sfp::Planner.new
+			planner.solve({:sfp => task, :pretty_json => true})
+		end
+=end
+
+
+
+=begin
+	module Helper
+		def self.create_object(name)
+			{ '_self' => name, '_context' => 'object', '_isa' => '$.Object', '_classes' => ['$.Object'] }
+		end
+
+		def self.create_state(name)
+			{ '_self' => name, '_context' => 'state' }
+		end
+
+		def self.to_state(name, value)
+			raise Exception, 'Given value should be a Hash!' if not value.is_a?(Hash)
+			value['_self'] = name
+			value['_context'] = 'state'
+			value
+		end
+
+		module Constraint
+			def self.equals(value)
+				{ '_context' => 'constraint', '_type' => 'equals', '_value' => value }
+			end
+
+			def self.and(name)
+				{ '_context' => 'constraint', '_type' => 'and', '_self' => name }
+			end
+		end
+
+		class GoalGenerator
+			attr_reader :results
+
+			def initialize
+				@results = Sfp::Helper::Constraint.and('goal')
+			end
+				
+			def visit(name, value, parent)
+				return false if name[0,1] == '_'
+				if value.is_a?(Hash)
+					return true if value['_context'] == 'object'
+					return false
+				end
+
+				@results[ parent.ref.push(name) ] = Sfp::Helper::Constraint.equals(value)
+				false
+			end
+		end
+	end
+=end

data/lib/sfpagent.rb

@@ -0,0 +1,14 @@
+# external dependencies
+require 'rubygems'
+require 'json'
+require 'sfp'
+
+# internal dependencies
+libdir = File.expand_path(File.dirname(__FILE__))
+
+require libdir + '/sfpagent/executor.rb'
+
+require libdir + '/sfpagent/runtime.rb'
+require libdir + '/sfpagent/module.rb'
+
+require libdir + '/sfpagent/agent.rb'

data/sfpagent.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+	s.name			= 'sfpagent'
+	s.version		= '0.0.1'
+	s.date			= '2013-07-03'
+	s.summary		= 'SFP Agent'
+	s.description	= 'A Ruby gem that provides a script of an SFP Agent.'
+	s.authors		= ['Herry']
+	s.email			= 'herry13@gmail.com'
+
+	s.executables << 'sfpagent'
+	s.files			= `git ls-files`.split("\n").select { |n| !(n =~ /^(modules|test)\/.*/) }
+
+	s.require_paths = ['lib']
+
+	s.homepage		= 'https://github.com/herry13/sfpagent'
+	s.rubyforge_project = 'sfpagent'
+
+	s.add_dependency 'sfp', '~> 0.3.0'
+end	

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: sfpagent
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Herry
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sfp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: A Ruby gem that provides a script of an SFP Agent.
+email: herry13@gmail.com
+executables:
+- sfpagent
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- bin/cert.rb
+- bin/sfpagent
+- lib/sfpagent.rb
+- lib/sfpagent/agent.rb
+- lib/sfpagent/executor.rb
+- lib/sfpagent/module.rb
+- lib/sfpagent/runtime.rb
+- sfpagent.gemspec
+homepage: https://github.com/herry13/sfpagent
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: sfpagent
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: SFP Agent
+test_files: []