nuri 0.5.1

data/lib/nuri/net_helper.rb

@@ -0,0 +1,65 @@
+require 'uri'
+require 'net/http'
+
+module Nuri::Net
+end
+
+module Nuri::Net::Helper
+	def post_data(address, port, path, data, open_timeout=5, read_timeout=1800)
+		uri = create_uri(address, port, path)
+		req = Net::HTTP::Post.new(uri.path)
+		req.set_form_data(data)
+		http_request(uri, req, open_timeout, read_timeout)
+	end
+
+	def put_data(address, port, path, data, open_timeout=5, read_timeout=1800)
+		uri = create_uri(address, port, path)
+		req = Net::HTTP::Put.new(uri.path)
+		req.set_form_data(data)
+		http_request(uri, req, open_timeout, read_timeout)
+	end
+
+	def get_data(address, port, path, open_timeout=5, read_timeout=1800)
+		uri = create_uri(address, port, path)
+		req = Net::HTTP::Get.new(uri.path)
+		http_request(uri, req, open_timeout, read_timeout)
+	end
+
+	def delete_data(address, port, path, open_timeout=5, read_timeout=1800)
+		uri = create_uri(address, port, path)
+		req = Net::HTTP::Delete.new(uri.path)
+		http_request(uri, req, open_timeout, read_timeout)
+	end
+
+	private
+	def create_uri(address, port, path)
+		address = address.to_s.strip
+		port = port.to_s.strip
+		path = path.to_s.strip
+		raise Exception, "Invalid parameters [address:#{address},port:#{port},path:#{path}]" if
+			address.length <= 0 or port.length <= 0 or path.length <= 0
+		path.sub!(/^\/+/, '')
+		URI.parse("http://#{address}:#{port}/#{path}")
+	end
+
+	def use_http_proxy?(uri)
+		ENV['no_proxy'].to_s.split(',').each { |pattern|
+			pattern.chop! if pattern[-1] == '*'
+			return false if uri.host[0,pattern.length] == pattern
+		}
+		true
+	end
+
+	def http_request(uri, request, open_timeout=5, read_timeout=1800)
+		if ENV['http_proxy'].to_s.strip != '' and use_http_proxy?(uri)
+			proxy = URI.parse(ENV['http_proxy'])
+			http = Net::HTTP::Proxy(proxy.host, proxy.port).new(uri.host, uri.port)
+		else
+			http = Net::HTTP.new(uri.host, uri.port)
+		end
+		http.open_timeout = open_timeout
+		http.read_timeout = read_timeout
+		http.start
+		http.request(request) { |res| return [res.code, res.body] }
+	end	
+end

data/lib/nuri/orchestrator.rb

@@ -0,0 +1,224 @@
+require 'thread'
+
+module Nuri::Orchestrator
+	include Nuri::Net::Helper
+
+	def execute_plan(p={})
+		raise Exception, "Plan file is not exist!" if not File.exist?(p[:execute].to_s) and !p[:plan]
+		raise Exception, "Plan is not exist (parameter :plan must be given)!" if !p[:plan]
+
+		push_agents_list
+
+		success = false
+		benchmark = Benchmark.measure {
+			plan = (p[:plan] ? p[:plan] : JSON[File.read(p[:execute])])
+			raise Exception, "Invalid plan!" if plan['workflow'].nil?
+			if plan.is_a?(Hash) and plan['type'] == 'sequential'
+				success = execute_sequential_plan(plan, p)
+			elsif plan.is_a?(Hash) and plan['type'] == 'parallel'
+				success = execute_parallel_plan(plan, p)
+			end
+		}
+		puts "Execution time (s): #{benchmark}"
+
+		success
+	end
+
+	protected
+	def send_action_data(action, address, port)
+		action['parameters'].each do |name,value|
+			next if !value.is_a?(String) or !value.isref or value.split('.').length > 2
+			_, target_name = value.split('.', 2)
+			data = {'model' => Sfp::Helper.deep_clone(@model[target_name])}
+			data.accept(Sfp::Visitor::ParentEliminator.new)
+			data = {'model' => JSON.generate(data)}
+			code = nil
+			begin
+				code, _ = put_data(address, port, "/model/cache/#{target_name}", data)
+			rescue
+			end
+			if code != '200'
+				$stderr.puts "Sending action data of #{value} to #{address}:#{port} [Failed]".red
+				return false
+			end
+		end
+
+		true
+	end
+
+	def execute_action(action)
+		_, agent_name, _ = action['name'].split('.', 3)
+		agents = get_agents
+
+		return false if !agents[agent_name]['sfpAddress'].is_a?(String)
+
+		address = agents[agent_name]['sfpAddress'].to_s
+		port = agents[agent_name]['sfpPort'].to_s
+
+		raise Exception, "Cannot find address:port of agent #{agent_name}" if
+			address.length <= 0 or port.length <= 0
+
+		send_action_data(action, address, port)
+
+		data = {'action' => JSON.generate(action)}
+		code, _ = post_data(address, port, '/execute', data)
+		if code.to_i == 200
+			# if the action is "create_vm" or "delete_vm", then
+			# update the VMs' address, and then push agents list
+			postprocess_create_or_delete_vm(action) if action['name'] =~ /^\$(\.[a-zA-Z0-9_]+)*\.(create_vm|delete_vm)/
+			true
+		else
+			false
+		end
+	end
+
+	def postprocess_create_or_delete_vm(action)
+		@mutex_postprocess = Mutex.new if !defined?(@mutex_postprocess)
+
+		@mutex_postprocess.synchronize {
+			_, agent_name, _ = action['name'].split('.', 3)
+	
+			state = {agent_name => get_node_state(agent_name)}
+			vms1, vms2 = update_vms_address(state)
+	
+			if action['name'] =~ /^\$(\.[a-zA-Z0-9_]+)*\.(create_vm)/
+				vm_name = action['parameters']['$.vm'].sub(/^\$\./, '')
+				get_node_state(vm_name, true)
+				
+			elsif action['name'] =~ /^\$(\.[a-zA-Z0-9_]+)*\.(delete_vm)/
+				model = @model.at?(action['parameters']['$.vm'])
+				if model.is_a?(Hash)
+					model['sfpAddress'] = {'_context'=>'any_value','_isa'=>'$.String'}
+					model['sfpPort'] = {'_context'=>'any_value','_isa'=>'$.Number'}
+				end
+			end
+	
+			push_agents_list
+		}
+	end
+
+	def execute_sequential_plan(plan, p)
+		begin
+			index = 1 
+			plan['workflow'].each do |action|
+				print "#{index}. #{action['name']} #{JSON.generate(action['parameters'])}... "
+				if execute_action(action)
+					puts "[OK]".green
+				else
+					puts "[Failed]".red
+					return false
+				end 
+				index += 1
+			end 
+			return true
+		rescue Exception => e
+			puts "#{e}\n#{e.backtrace.join("\n")}".red
+		end 
+		false
+	end 
+
+	def execute_parallel_plan(plan, options)
+		@retries = 2
+
+		@actions = plan['workflow']
+		@actions.sort! { |x,y| x['id'] <=> y['id'] }
+		@actions.each { |op|
+			op[:executed] = false
+			op[:executor] = nil
+			op[:string] = "#{op['id'] + 1}: #{op['name']} #{JSON.generate(op['parameters'])}"
+		}		
+
+		@threads = []
+		@actions_failed = []
+		@mutex = Mutex.new
+		@failed = false
+		@thread_id = 0
+
+		def next_thread_id
+			id = 0
+			@mutex.synchronize { @thread_id = id = @thread_id + 1 }
+			id
+		end
+
+		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 thread_execute_action(tid, action)
+			t = Thread.new {
+				# Register the thread
+				@mutex.synchronize { @threads << tid }
+
+				while not @failed and not action[:executed]
+					# Try to execute the action
+					puts "Executing #{action[:string]} - thread ##{tid} [WAIT]".yellow
+					success = false
+					1.upto(@retries) do |i|
+						begin
+							success = execute_action(action)
+						rescue Exception => exp
+							puts "Executing(#{i}) #{action[:string]} - thread ##{tid} [FAILED]\n#{exp}\n#{exp.backtrace.join("\n")}"
+						end
+						break if success
+					end
+
+					# Check if execution failed
+					if success
+						# Execution was success
+						puts "Executing #{action[:string]} - thread ##{tid} [OK]".green
+						next_actions = []
+						@mutex.synchronize {
+							action[:executed] = true # set executed
+							# select next action to be executed from successor actions list
+							# select a successor action that has not been assigned to any thread yet
+							if action['successors'].length > 0
+								action['successors'].each { |id|
+									if @actions[id][:executor].nil?
+										# check if all predecessors actions have been executed
+										predecessors_ok = true
+										@actions[id]['predecessors'].each { |pid|
+											predecessors_ok = (predecessors_ok and @actions[pid][:executed])
+										}
+										# assign this action to be executed by this thread if all predecessors
+										# have been executed
+										next_actions << id if predecessors_ok
+									end
+								}
+							end
+							next_actions.each { |id| @actions[id][:executor] = tid }
+						}
+						if next_actions.length > 0				
+							# execute the first next actions to this thread
+							action = @actions[next_actions[0]]
+							if next_actions.length > 1
+								# execute other next actions to other threads
+								for i in 1..(next_actions.length-1)
+									assign_action_with_id(next_actions[i])
+								end
+							end
+						end
+
+					else
+						# Execution was failed
+						puts "Executing #{action[:string]} - thread ##{tid} [FAILED]".red
+						@mutex.synchronize {
+							@failed = true # set global flag to stop the execution
+							@actions_failed << action
+						}
+					end
+				end
+
+				@mutex.synchronize { @threads.delete(tid) }
+			}
+		end
+
+		plan['init'].each { |id| assign_action_with_id(id) }
+		begin
+			sleep 1
+		end while @threads.length > 0
+		(not @failed)
+	end
+end

data/lib/nuri/server.rb

@@ -0,0 +1,212 @@
+require 'yaml'
+require 'logger'
+require 'webrick'
+
+module Nuri::Server
+	VarDir = (Process.euid == 0 ? '/var/nuri' : File.expand_path('~/.nuri'))
+	Dir.mkdir(VarDir, 0700) if not File.exist?(VarDir)
+
+	PIDFile = "#{VarDir}/nuri.pid"
+	PlanFile = "#{VarDir}/plan.json"
+	LogFile = "#{VarDir}/nuri.log"
+	ModelFile = "#{VarDir}/main.sfp"
+	ModulesDir = "#{VarDir}/modules"
+	Dir.mkdir(ModulesDir, 0700) if not File.exist?(ModulesDir)
+
+	ConfigDir = (Process.euid == 0 ? '/etc/nuri' : File.expand_path('~/.nuri'))
+	ConfigFile = "#{ConfigDir}/nuri.yml"
+
+	DefaultIntervalTime = 5
+	DefaultPort = 1313
+
+	def init
+		Dir.mkdir(ConfigDir, '0755') if not File.exist?(ConfigDir)
+
+		if not File.exist?(ConfigFile)
+			# generate and save default configuration file
+			config = { "port" => DefaultPort,
+			           "interval_time" => 5 }
+			File.open(ConfigFile, 'w', 0644) { |f| f.write(YAML.dump(config)) }
+
+			# generate an empty model file
+			File.open(ModelFile, 'w', 0644) { |f| f.write('') }
+		end
+
+		#if not File.exist?(".git")
+		#	system("cd #{ConfigDir}; git init 1>/dev/null 2>/dev/null")
+		#	File.open("#{ConfigDir}/.gitignore", 'w', 0644) { |f| f.write("*.pid\n*.log\n") }
+		#	system("cd #{ConfigDir}; git add -A . 1>/dev/null 2>/dev/null; git commit -m 'nuri init' 1>/dev/null 2>/dev/null")
+		#end
+	end
+
+	def start
+		if not File.exist?(ConfigFile)
+			puts "Execute 'nuri init' first!"
+			exit!(1)
+		end
+
+		if File.exist?(PIDFile)
+			pid = File.read(PIDFile).to_i
+			begin
+				Process.kill 0, pid if pid > 0
+				# Nuri server is still running
+				puts "Nuri server is already running with PID #{pid}."
+				exit!(1)
+			rescue
+			end
+		end
+
+		@logger = WEBrick::Log.new(LogFile, WEBrick::BasicLog::INFO ||
+		                                    WEBrick::BasicLog::ERROR ||
+		                                    WEBrick::BasicLog::FATAL ||
+		                                    WEBrick::BasicLog::WARN)
+
+		@logger.info "Reading configuration file [Wait]"
+		@config = YAML.load(File.read(ConfigFile))
+		@logger.info "Reading configuration file [OK]"
+
+		['INT', 'KILL', 'HUP'].each { |signal|
+			trap(signal) {
+				@logger.info "Shutting down Nuri server..."
+				@enabled = false
+				@web_server.shutdown
+			}
+		}
+
+		puts "Starting Nuri server..."
+		Process.daemon
+
+		File.open("#{PIDFile}", 'w', 0644) { |f| f.write($$.to_s) }
+
+		start_web_server
+
+		start_nuri_server
+	end
+
+	def start_nuri_server
+		@enabled = true
+		@logger.info "Nuri server is running."
+
+		options = { :parallel     => true,
+		            :model_file   => ModelFile,
+		            :apply        => true,
+		            :push_modules => true,
+		            :modules_dir  => ModulesDir,
+		            :silent       => true }
+
+		interval_time = (@config['interval_time'] ? @config['interval_time'].to_i : DefaultIntervalTime)
+
+		while @enabled
+			@logger.info "Executing the model."
+
+			plan = nil
+			begin
+				#plan = get_plan if File.exist?(ModelFile)
+
+				if plan.is_a?(Hash)
+					File.open(PlanFile, 'w', '0644') { |f| f.write(JSON.pretty_generate(plan)) }
+					@logger.info "Executing the generated plan in file #{PlanFile}."
+					options[:plan] = plan
+					if execute_plan(options)
+						@logger.info "Execution is success!"
+					else
+						@logger.info "Execution is failed!"
+					end
+				end
+
+			rescue Exception => e
+				@logger.error "Error: #{e}\n#{e.backtrace.join("\n")}"
+			end
+	
+			sleep interval_time
+		end
+
+		@logger.info "Nuri server has stopped."
+	end
+
+	def start_web_server
+		Thread.new {
+			config = { :Host => '0.0.0.0',
+			           :Port => (@config['port'] ? @config['port'].to_i : DefaultPort),
+			           :ServerType => WEBrick::SimpleServer,
+			           :Logger => @logger }
+			@web_server = WEBrick::HTTPServer.new(config)
+			@web_server.mount('/', Nuri::Server::Handler, self, @logger)
+			@web_server.start
+		}
+	end
+
+	def stop
+		begin
+			pid = File.read(PIDFile).to_i
+			Process.kill 'HUP', pid
+			puts "Stopping Nuri server..."
+		rescue
+			puts "Nuri server is not running."
+		end
+	end
+
+	def get_model(p={})
+		(File.exist?(ModelFile) ? File.read(ModelFile) : '')
+	end
+
+	def get_log(total_lines=0)
+		(File.exist?(LogFile) ? `tail -n #{total_lines} #{LogFile}` : '')
+	end
+
+	class Handler < WEBrick::HTTPServlet::AbstractServlet
+		def initialize(server, master, logger)
+			@master = master
+			@logger = logger
+		end
+
+		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 == '/model'
+					status, content_type, body = [200, 'text/plain', @master.get_model(:json => true)]
+				elsif path == '/log'
+					status, content_type, body = [200, 'text/plain', @master.get_log(100)]
+				end
+			end
+
+			response.status = status
+			response['Content-Type'] = content_type
+			response.body = body
+		end
+
+		def do_POST(request, response)
+			status = 400
+			content_type, body = ''
+
+			response.status = status
+			response['Content-Type'] = content_type
+			response.body = body
+		end
+
+		def do_PUT(request, response)
+			status = 400
+			content_type, body = ''
+
+			response.status = status
+			response['Content-Type'] = content_type
+			response.body = body
+		end
+
+		def trusted(address)
+			# TODO
+			true
+		end
+	end
+end
+
+#nuri = Object.new
+#nuri.extend(Nuri::Server)
+#nuri.init
+#nuri.start
+#nuri.stop