manqod-server 1.257.0

data/lib/DrbDB/Users.rb

@@ -0,0 +1,61 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the owner of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+class Users
+	include Eprint
+	include DRbUndumped
+	def initialize(drbdb)
+		@drbdb=drbdb
+		@users=Hash.new
+		@groups=Hash.new
+		@usergroups=Hash.new
+	end
+	attr_reader :drbdb
+
+	def load_all
+		@users.clear
+		@groups.clear
+		@usergroups.clear
+		drbdb.admin.rows("select * from users").each{|row|
+			@users[row["id"].to_i]=row
+		}
+		einfo("#{@users.length} users\n")
+		drbdb.admin.rows("select * from groups").each{|row|
+			@groups[row["id"].to_i]=row
+		}
+		drbdb.admin.rows("select * from usergroups").each{|row|
+			@usergroups[row["id"].to_i]=row
+		}
+		self
+	end
+	
+	def user_in_group?(user_id,group_id)
+		found=false
+		@usergroups.each_value{|ugrp|
+			found=true if ugrp["userid"].to_i == user_id && ugrp["groupid"].to_i == group_id
+		}
+		found
+	end
+
+	def get_user(user_id)
+		@users[user_id]
+	end
+
+	def each
+		@users.each_key{|im_key| yield im_key}
+	end
+	def auth?(nick,password)
+		found=false
+		@users.each{|key,user|
+			found=true if nick.to_s == user["nick"].to_s && user["passwd"].to_s == password.to_s
+		}
+		found
+	end
+	
+
+	def to_s
+		"Users of #{drbdb}"
+	end
+end
+

data/lib/DrbDB.rb

@@ -0,0 +1,274 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the author of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+class DrbDb
+	include Eprint
+	include DRbUndumped
+	include SQL
+	include Help
+	include Cron
+	include GtkAttributes
+	include EventCache
+	include Messaging
+	
+	INIT=0
+	LOADING=1
+	SERVING=2
+
+	def initialize(connection,main_server_uri)
+		@state=INIT
+		@connection=connection
+		@main_server_uri=main_server_uri
+		@moditems=Hash.new #[moditem_id][id][fields]
+		@server=nil
+#		@relations=Hash.new
+#		@server=DRb::DRbServer.new(@connection['uri'],self)
+	end
+	attr_reader :uri, :moditems, :admin, :client, :cache, :connection, :images, :state
+	attr_accessor :server, :main_server
+
+	def init
+		einfo("Memcached #{Memcached::VERSION}")
+	  @cache = Memcached.new([@connection['cache_host']],{:prefix_key=>key_name, :default_ttl => 0, :timeout => 2})
+		DRb.start_service(@connection["uri"],self)
+		@server=DRb.current_server()
+		@main_server=DRb::DRbObject.new_with_uri(@main_server_uri)
+		@uri=server.uri()
+		unless init_sql(@connection['sql_host'],@connection['sql_user'],@connection['sql_password'],@connection['sql_db'])
+			eerror("connection to sql server failed: #{@connection['sql_user']}@#{@connection['sql_host']}/#{@connection['sql_db']}")
+			return nil
+		end
+		update_manqod_db
+		begin
+			begin
+				@admin=DRb::DRbObject.new(nil,@connection['admin_uri'])
+				we_have_admin=@admin.alive?
+			rescue
+				ewarn("no admin?")
+				sleep 1
+			end
+		end until we_have_admin
+		begin
+			@state=LOADING
+			load_all_attributes
+
+			admin.rows("select moditems.id,modules.modname,moditems.display from moditems left join modules on modules.id = moditems.modid").each{|moditem|
+				begin
+					case moditem["modname"]
+						when "listing"
+							@moditems[moditem["id"].to_i]=DrbListModel.new(self,moditem["id"].to_i).create_skeleton unless @moditems.has_key?(moditem["id"])
+							@moditems[moditem["id"].to_i].update(self)
+						when "form"
+							@moditems[moditem["id"].to_i]=DrbForm.new(self,moditem["id"].to_i).create_skeleton unless @moditems.has_key?(moditem["id"])
+						else
+							ewarn("not caching #{moditem['display']}[#{moditem['modname']}]")
+					end
+				rescue =>err
+					ewarn("error loading moditem: #{moditem.inspect}")
+					eexception(err,:moditem => moditem)
+				end
+			}
+			@images=DrbImages.new(self).load_all
+			@users=Users.new(self).load_all
+			load_all_events
+			load_all_help
+			start_cron
+			@state=SERVING
+		rescue => err
+			eerror("failed to start: #{err}")
+			retry
+		end
+
+		DRb.thread.join
+		einfo("EXITED")
+		exit
+	end
+	
+	def setup_client
+		if @connection['client_uri'].length>0
+			begin
+				@client=DRb::DRbObject.new(nil,@connection['client_uri'])
+				einfo("client is alive?(#{@client}): #{@client.alive?}")
+			rescue
+				@client=nil
+				einfo("no client.")
+			end
+		end
+	end
+	def name
+		@connection['name']
+	end
+	def key_name
+		@connection['key_name']
+	end
+
+
+	def moditem(mod_id)
+		@moditems[mod_id.to_i]
+	end
+	
+	def reload_moditem(moditem_id)
+		@state=LOADING
+		if moditem(moditem_id).nil?
+			einfo("creating moditem ##{moditem_id}")
+			#moditem added
+			admin.rows("select moditems.id,modules.modname,moditems.display
+			from moditems 
+			left join modules on modules.id = moditems.modid
+			where moditems.id='#{moditem_id}'").each{|moditem|
+			begin
+				case moditem["modname"]
+					when "listing"
+						@moditems[moditem["id"].to_i]=DrbListModel.new(self,moditem["id"].to_i).create_skeleton unless @moditems.has_key?(moditem["id"])
+						@moditems[moditem["id"].to_i].update(self)
+					when "form"
+						@moditems[moditem["id"].to_i]=DrbForm.new(self,moditem["id"].to_i).create_skeleton unless @moditems.has_key?(moditem["id"])
+					else
+						eerror("not caching #{moditem['display']}[#{moditem['modname']}]")
+				end
+			rescue =>err
+				ewarn("error loading moditem: #{moditem.inspect}")
+				eexception(err,:moditem => moditem)
+			end
+			}
+			
+		else
+			einfo("reloading moditem ##{moditem_id}")
+			case moditem(moditem_id).mod_type
+				when "list"
+					new_model=DrbListModel.new(self,moditem_id).create_skeleton
+					edebug("#{new_model} created")
+					new_model.update(self)
+					unless @moditems[moditem_id.to_i].nil?
+						@moditems[moditem_id.to_i].clients.each{|c| new_model.subscribe(c)}
+						edebug("#{@moditems[moditem_id.to_i]} abandoned")
+					end
+					@moditems[moditem_id.to_i]=new_model
+					@moditems[moditem_id.to_i].notify_clients(nil,"structure")
+				when "form"
+					moditem(moditem_id).create_skeleton
+			end
+		end
+		@state=SERVING
+	end
+	
+	def reload_users
+		@users.load_all
+	end
+	
+	def reload_client_images
+		main_server.connected_clients.each_pair{|cc,cdb|
+			if cdb == client.name
+				einfo("sending reload images to #{cc}")
+				cc.rpc("DrbImages.instance.load_images")
+			end
+		}
+	end
+	
+	def reload_client_attributes
+		client.load_all_attributes
+		main_server.connected_clients.each_pair{|cc,cdb|
+			if cdb == client.name
+				begin
+					einfo("sending reload attribute to #{cc}")
+					cc.rpc("GtkAttributeStorage.instance.load_all")
+				rescue => err
+					ewarn("cannot send reload attributes #{err}")
+				end
+			end
+		}
+	end
+
+	def reload_client_events(goid)
+		einfo("changed client event: #{goid}")
+		client.events(goid,true)
+		main_server.connected_clients.each_pair{|cc,cdb|
+			if cdb == client.name
+				begin
+					einfo("sending reload event to #{cc}")
+					cc.rpc("EventCache.instance.reload_events(\"#{goid}\")")
+				rescue => err
+					ewarn("cannot send reload events #{err}")
+				end
+			end
+		}
+	end
+
+	def auth?(nick,password)
+		r=@users.auth?(nick,password)
+		edebug("auth?(#{nick}):#{r}")
+		r
+	end
+	def sendmail(nick,subject,body)
+		sendmail_to_nick(nick,subject,body)
+	end
+	def user_in_group?(user_id,group_id)
+		@users.user_in_group?(user_id,group_id)
+	end
+	
+	def moditems_with_base(base)
+		@moditems.each_value{|drblist|
+			yield drblist if drblist && drblist.mod_type == "list" && drblist.base == base
+		}
+	end
+	
+	def changed_ids_of_base(base,ids,nick=nil)
+		base_moditem=nil
+		moditems_with_base(base){|b|
+			base_moditem=b
+		}
+		unless base_moditem.nil?
+			base_moditem.rows_changed(ids,nick)
+		end
+	end
+
+	def lock_id_of_base(base,lid)
+		ids=if lid.class == Array then lid else [lid] end
+		moditems_with_base(base){|b| ids.each{|iid| b.lock_iter(iid)}}
+	end
+
+	def unlock_id_of_base(base,lid)
+		ids=if lid.class == Array then lid else [lid] end
+		moditems_with_base(base){|b| ids.each{|iid| b.unlock_iter(iid)}}
+	end
+	
+	def each_moditem(modtype = "list")
+		@moditems.each_value{|m|
+			yield m if m.mod_type == modtype
+		}
+	end
+	
+	def remove_dead_clients
+		cnt=0
+		@moditems.each_value{|m| cnt+=m.remove_dead_clients if m.mod_type == "list"}
+		cnt
+	end
+
+	def alive?
+		true
+#		server.alive?
+	end
+
+#	def method_missing(sym,*args)
+#		p "#{self} missing method: #{sym}(#{args})"
+#	end
+
+	def report_mail(subject, variables)
+		@main_server.report_mail(subject,variables)
+	end
+	
+	def exit
+		@server.stop_service
+		super
+	end
+	
+	def serving?
+		@state==SERVING
+	end
+
+	def to_s
+		"[ManqodDb #{name}(#{Process.pid})]"
+	end
+end
+

data/lib/Eprint.rb

@@ -0,0 +1,94 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the author of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+module Eprint
+	TERM_COLOUR={
+		Logger::Severity::DEBUG => 33,
+		Logger::Severity::INFO => 32,
+		Logger::Severity::WARN => 35,
+		Logger::Severity::ERROR => 31,
+		Logger::Severity::FATAL => 31,
+		Logger::Severity::UNKNOWN => 36
+	}
+	def eprint(subject,level=Logger::Severity::UNKNOWN)
+		begin
+	 		ManqodLogger.instance.log(level,"\e[1;37m#{self}\e[0m:\e[#{TERM_COLOUR[level]}m#{subject}\e[0m")
+	 	rescue => err
+	 		print("#{err}\n")
+	 		ManqodLogger.instance.set_level("ERROR")
+	 		retry
+	 	end
+	end
+
+	def edebug(subject)
+		eprint(subject,Logger::Severity::DEBUG)
+	end
+
+	def einfo(subject)
+		eprint(subject,Logger::Severity::INFO)
+	end
+
+	def ewarn(subject)
+		eprint(subject,Logger::Severity::WARN)
+	end
+
+	def eerror(subject)
+		eprint(subject,Logger::Severity::ERROR)
+	end
+	def efatal(subject)
+		eprint(subject,Logger::Severity::FATAL)
+	end
+
+	def ecode(subject)
+		eprint(subject,Logger::Severity::UNKNOWN)
+	end
+
+	def report_mail(subject, variables)
+		return unless ManqodLogger.instance.report_address
+		fork{
+		begin
+		msg="From: manqod@#{Socket.gethostbyname(Socket.gethostname).first}\nTo: #{ManqodLogger.instance.report_address}\nSubject: #{subject}\n"
+		variables.each_pair{|k,v| msg="#{msg}\n#{k}: #{v}\n--------------------"}
+
+			Net::SMTP.start('localhost'){ |smtp|
+				smtp.send_message(msg, "manqod_server", ManqodLogger.instance.report_address)
+				einfo("report sent: #{subject} to {ManqodLogger.instance.report_address}")
+			}
+		rescue => err
+			eerror("can't send error report via SMTP")
+		end
+		}
+	end
+
+	def eexception(ex,*args)
+		eerror("error: #{ex}\n#{ex.backtrace.join("\n")}")
+		report_mail(ex,{
+			'error'=>ex.inspect,
+			'backtrace'=>ex.backtrace.join("\n"),
+			'class' => self.class,
+			'self'=>self.inspect,
+			'arguments' => args.inspect
+			})
+	end
+
+	def eeval(command,context=self)
+  	ret=nil
+  	begin
+			if context and b=context.getBinding then
+				ret=eval(command, b)
+				else
+				ret=eval(command)
+			end
+		rescue SyntaxError, NameError => err
+	  	eexception(err,:command=>command,:context=>context)
+  	end
+  	ret
+	end
+	
+	def getBinding
+		binding
+	end
+
+end
+

data/lib/HeartBeat.rb

@@ -0,0 +1,54 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the author of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+module HeartBeat
+	def init_HeartBeat
+		@headerbeat_thread=Thread.new{
+			lalive_clients=-1
+			lalive_client_lists=-1
+			loop do
+				begin
+					sleep 10
+					to_remove=Array.new
+					alive_clients=0
+					@connected_clients.each_pair{|cc,db|
+						begin
+							cc.alive?
+							alive_clients+=1
+						rescue
+							to_remove.push(cc)
+						end
+					}
+					to_remove.each{|dead|
+						ewarn("removed dead client: #{dead.inspect}")
+			 			@connected_clients.delete(dead)
+					}
+
+					alive_client_lists=0
+					@dbs.each_value{|db|
+						next unless db.serving?
+						#keep the conenction to the cache alive
+						db.cache.set("alive",Time.new)
+						#check for alive client list subscriptions
+						alive_client_lists+=db.remove_dead_clients
+					}
+					einfo("#{alive_clients} clients  #{alive_client_lists} subscriptions alive") unless alive_clients==lalive_clients && alive_client_lists==lalive_client_lists
+
+					lalive_clients=alive_clients
+					lalive_client_lists=alive_client_lists
+				rescue ECONNREFUSED => err
+					eerror("HeartBeat: #{err}")
+				rescue =>err
+					eerror("HeartBeat error: #{err}\n#{err.backtrace.join("\n")}")
+				end
+			end
+		}
+		einfo("HeartBeat started")
+	end
+	def stop_HeartBeat
+		@heartbeat_thread.kill
+		einfo("HeartBeat stopped")
+	end
+end
+

data/lib/ManqodLogger.rb

@@ -0,0 +1,27 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the author of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+class ManqodLogger < Logger::Application
+	include Singleton
+
+	LEVEL_MAP={
+		"DEBUG" => Logger::Severity::DEBUG,
+		"INFO"	=> Logger::Severity::INFO,
+		"WARN"	=> Logger::Severity::WARN,
+		"ERROR"	=> Logger::Severity::ERROR,
+		"FATAL"	=> Logger::Severity::FATAL,
+		"UNKNOWN"	=> Logger::Severity::UNKNOWN
+	}
+
+	@report_address=nil
+	attr_reader :report_address
+
+	def set_level(llevel)
+		self.level=LEVEL_MAP[llevel]
+	end
+	def set_report_address(ra)
+		@report_address=ra
+	end
+end
+

data/lib/ManqodServer.rb

@@ -0,0 +1,167 @@
+#this file is part of manqod
+#manqod is distributed under the CDDL licence
+#the author of manqod is Dobai-Pataky Balint(dpblnt@gmail.com)
+
+class ManqodServer
+	include Eprint
+	include DRb
+	include DRbUndumped
+	include HeartBeat
+	include DBSetup
+	def initialize(opts)
+		@starting_up=true
+		@uri=opts[:bind]
+		@logdev=opts[:log]
+		@log_level=opts[:debug]
+		@report_address=opts[:report]
+		@path=opts[:path]
+		@connections_conf=File::expand_path(File.join(File.join(@path,"etc"),"connections.conf"))
+		@conns=Hash.new
+		@dbs=Hash.new
+		@connected_clients=Hash.new
+	end
+	attr_reader :dbs, :connected_clients, :uri
+	attr_reader :starting_up
+	
+	def init
+		ManqodLogger.instance.set_log(@logdev) if @logdev
+		einfo("setting log level to #{@log_level}")
+		ManqodLogger.instance.set_level(@log_level) if @log_level
+		ManqodLogger.instance.set_report_address(@report_address) if @report_address
+		load_conns
+		begin
+			DRb.start_service(@uri,self)
+		rescue =>err
+			eerror("starting main server failed: #{err}")
+			return false
+		end
+		@conns.sort{|a,b| a[1]["auto_load_order"] <=> b[1]["auto_load_order"]}.each{|conn| 
+			load_conn(conn[0]) if conn[1]["auto_load"]
+		}
+		setup_clients
+		init_HeartBeat
+		@starting_up=false
+		eprint("serving")
+		DRb.thread.join
+		einfo("graceful shutdown")
+	end
+	
+	def setup_clients
+		#wait for all clients to start up
+		begin
+		begin
+			found=false
+			@dbs.each_value{|drbdb|
+				unless drbdb.serving?
+					found = true 
+					sleep 1
+				end
+			}
+		end while found
+		@dbs.each_pair{|conn_name,drbdb| drbdb.setup_client unless drbdb.client and drbdb.client.alive?}
+		rescue
+		end
+	end
+
+	def conn(conn_name)
+		@conns[conn_name]
+	end
+	
+	def conn_list
+		@conns.each_pair{|conn_name,conn|
+			yield conn_name,conn
+		}
+	end
+	
+	def default_connection
+		dc=nil
+		@conns.each_pair{|cn,c| dc=c if c.has_key?("client_default") && c["client_default"]}
+		dc
+	end
+	
+	def reload_conn(conn_name)
+		if @conns.has_key?(conn_name)
+			free_conn(conn_name) if @dbs.has_key?(conn_name)
+			load_conn(conn_name)
+			setup_clients
+		end
+	end
+
+	def load_conn(conn_name)
+		if @conns.has_key?(conn_name)
+			begin
+				@conns[conn_name]["key_name"]=conn_name
+				@conns[conn_name]['pid']=fork{
+					th=DrbDb.new(@conns[conn_name],@uri)
+					th.init
+				}
+				Process.detach(@conns[conn_name]['pid'])
+				edebug("forked \"#{conn_name}\" [#{@conns[conn_name]['uri']}](#{@conns[conn_name]['pid']})")
+				
+				begin
+					sleep 1
+					@dbs[conn_name]=DRb::DRbObject.new_with_uri(@conns[conn_name]['uri'])
+#					@dbs[conn_name].alive?
+					@dbs[conn_name].state
+					@dbs[conn_name].setup_client
+					rescue => err
+					#check if pid is alive
+					begin
+						Process::kill(0,@conns[conn_name]['pid'])
+					rescue Errno::ESRCH
+						raise("Process with pid #{@conns[conn_name]['pid']} is dead")
+					end
+					ewarn("waiting for startup of #{conn_name} (#{err})")
+					retry
+				end while @dbs[conn_name].state != DrbDb::SERVING
+			rescue =>err
+				eerror("error starting connection:#{conn_name} #{err}, retrying")
+				sleep 1
+				retry
+			end
+		end
+	end
+	
+	def free_conn(conn_name)
+		if @dbs.has_key?(conn_name)
+			@dbs[conn_name].exit
+			@dbs.delete(conn_name)
+			einfo("#{conn_name} freed.")
+		end
+	end
+	
+	def stop
+		@dbs.each_key{|dbn| 
+			begin
+				free_conn(dbn)
+			rescue =>err
+				eerror("cannot stop #{dbn}:#{err}")
+			end
+		}
+		current_server.stop_service
+		einfo("server halted")
+		exit
+	end
+
+	def register_client(client,db)
+		@connected_clients[client]=db unless @connected_clients.has_key?(client)
+		einfo("#{client} registered to [#{db}]")
+	end
+	def unregister_client(client)
+		@connected_clients.delete(client)
+		einfo("#{client} unregistered")
+	end
+
+	def alive?
+		true
+	end
+	
+	def to_s
+		"ManqodServer"
+	end
+	
+#	def method_missing(sym,*args)
+#		p "#{self} missing method: #{sym}(#{args})"
+#	end
+end
+