knjappserver 0.0.6

data/lib/include/class_knjappserver_logging.rb

@@ -0,0 +1,272 @@
+class Knjappserver
+	def initialize_logging
+		@logs_access_pending = []
+		@logs_mutex = Mutex.new
+		
+		if @config[:logging] and @config[:logging][:access_db]
+			self.timeout(:time => 30) do
+				if @logs_access_pending.length > 0
+					flush_access_log
+				end
+			end
+		end
+	end
+	
+	def flush_access_log
+		@logs_mutex.synchronize do
+			ins_arr = @logs_access_pending
+			@logs_access_pending = []
+			inserts = []
+			inserts_links = []
+			
+			ins_arr.each do |ins|
+				gothrough = [{
+					:col => :get_keys_data_id,
+					:hash => ins[:get],
+					:type => :keys
+				},{
+					:col => :get_values_data_id,
+					:hash => ins[:get],
+					:type => :values
+				},{
+					:col => :post_keys_data_id,
+					:hash => ins[:post],
+					:type => :keys
+				},{
+					:col => :post_values_data_id,
+					:hash => ins[:post],
+					:type => :values
+				},{
+					:col => :cookie_keys_data_id,
+					:hash => ins[:cookie],
+					:type => :keys
+				},{
+					:col => :cookie_values_data_id,
+					:hash => ins[:cookie],
+					:type => :values
+				},{
+					:col => :meta_keys_data_id,
+					:hash => ins[:meta],
+					:type => :keys
+				},{
+					:col => :meta_values_data_id,
+					:hash => ins[:meta],
+					:type => :values
+				}]
+				ins_hash = {
+					:session_id => ins[:session_id],
+					:date_request => ins[:date_request]
+				}
+				
+				gothrough.each do |data|
+					if data[:type] == :keys
+						hash = Knj::ArrayExt.hash_keys_hash(data[:hash])
+					else
+						hash = Knj::ArrayExt.hash_values_hash(data[:hash])
+					end
+					
+					data_id = @ob.static(:Log_data, :by_id_hash, hash)
+					if !data_id
+						data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+						
+						link_count = 0
+						data[:hash].keys.sort.each do |key|
+							if data[:type] == :keys
+								ins_data = "#{key.to_s}"
+							else
+								ins_data = "#{data[:hash][key]}"
+							end
+							
+							ins_data = ins_data.force_encoding("UTF-8") if ins_data.respond_to?(:force_encoding)
+							data_value_id = @ob.static(:Log_data_value, :force_id, ins_data)
+							inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+							link_count += 1
+						end
+					end
+					
+					ins_hash[data[:col]] = data_id
+				end
+				
+				hash = Knj::ArrayExt.array_hash(ins[:ips])
+				data_id = @ob.static(:Log_data, :by_id_hash, hash)
+				
+				if !data_id
+					data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+					
+					link_count = 0
+					ins[:ips].each do |ip|
+            data_value_id = @ob.static(:Log_data_value, :force_id, ip)
+						inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+						link_count += 1
+					end
+				end
+				
+				ins_hash[:ip_data_id] = data_id
+				inserts << ins_hash
+			end
+			
+			@db.insert_multi(:Log_access, inserts)
+			@db.insert_multi(:Log_data_link, inserts_links)
+			@ob.unset_class([:Log_access, :Log_data, :Log_data_link, :Log_data_value])
+		end
+	end
+	
+	def log_hash_ins(hash_obj)
+		inserts_links = []
+		ret = {}
+		[:keys, :values].each do |type|
+			if type == :keys
+				hash = Knj::ArrayExt.hash_keys_hash(hash_obj)
+			else
+				hash = Knj::ArrayExt.hash_values_hash(hash_obj)
+			end
+			
+			data_id = @db.single(:Log_data, {"id_hash" => hash})
+			data_id = data_id[:id] if data_id
+			
+			if !data_id
+				data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+				
+				link_count = 0
+				hash_obj.keys.sort.each do |key|
+					if type == :keys
+						ins_data = "#{key.to_s}"
+					else
+						ins_data = "#{hash_obj[key].to_s}"
+					end
+					
+					ins_data = ins_data.force_encoding("UTF-8") if ins_data.respond_to?(:force_encoding)
+					data_value_id = @ob.static(:Log_data_value, :force_id, ins_data)
+					inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+					link_count += 1
+				end
+			end
+			
+			if type == :keys
+				ret[:keys_data_id] = data_id
+			else
+				ret[:values_data_id] = data_id
+			end
+		end
+		
+		@db.insert_multi(:Log_data_link, inserts_links)
+		
+		return ret
+	end
+	
+	def log_data_hash(keys_id, values_id)
+		keys_data_obj = @ob.get(:Log_data, keys_id)
+		values_data_obj = @ob.get(:Log_data, values_id)
+		
+		sql = "
+			SELECT
+				key_value.value AS `key`,
+				value_value.value AS value
+			
+			FROM
+				Log_data_link AS key_links,
+				Log_data_link AS value_links,
+				Log_data_value AS key_value,
+				Log_data_value AS value_value
+			
+			WHERE
+				key_links.data_id = '#{keys_id}' AND
+				value_links.data_id = '#{values_id}' AND
+				key_links.no = value_links.no AND
+				key_value.id = key_links.value_id AND
+				value_value.id = value_links.value_id
+			
+			ORDER BY
+				key_links.no
+		"
+		
+		hash = {}
+		q_hash = db.query(sql)
+		while d_hash = q_hash.fetch
+			hash[d_hash[:key].to_sym] = d_hash[:value]
+		end
+		
+		return hash
+	end
+	
+	def log(msg, objs)
+		@logs_mutex.synchronize do
+			objs = [objs] if !objs.is_a?(Array)
+			log_value_id = @ob.static(:Log_data_value, :force_id, msg)
+			ins_data = {
+				:date_saved => Time.new,
+				:text_value_id => log_value_id
+			}
+			
+			get_hash = log_hash_ins(_get) if _get
+			if get_hash
+				ins_data[:get_keys_data_id] = get_hash[:keys_data_id]
+				ins_data[:get_values_data_id] = get_hash[:values_data_id]
+			end
+			
+			post_hash = log_hash_ins(_post) if _post
+			if post_hash
+				ins_data[:post_keys_data_id] = post_hash[:keys_data_id]
+				ins_data[:post_values_data_id] = post_hash[:values_data_id]
+			end
+			
+			log_id = @db.insert(:Log, ins_data, {:return_id => true})
+			
+			log_links = []
+			objs.each do |obj|
+        class_data_id = @ob.static(:Log_data_value, :force_id, obj.class.name)
+        
+        log_links << {
+          :object_class_value_id => class_data_id,
+          :object_id => obj.id,
+          :log_id => log_id
+        }
+			end
+			
+			@db.insert_multi(:Log_link, log_links)
+		end
+	end
+	
+	def logs_table(obj, args = {})
+		links = @ob.list(:Log_link, {"object_class" => obj.class.name, "object_id" => obj.id, "limit" => 500, "orderby" => [["id", "desc"]]})
+		
+		html = "<table class=\"list knjappserver_log_table\">"
+		html += "<thead>"
+		html += "<tr>"
+		html += "<th>ID</th>"
+		html += "<th>Message</th>"
+		html += "<th>Date &amp; time</th>"
+		html += "<th>Objects</th>" if args[:ob_use]
+		html += "</tr>"
+		html += "</thead>"
+		html += "<tbody>"
+		
+		links.each do |link|
+      log = link.log
+      
+			msg_lines = log.text.split("\n")
+			first_line = msg_lines[0].to_s
+			
+			classes = ["knjappserver_log", "knjappserver_log_#{log.id}"]
+			classes << "knjappserver_log_multiple_lines" if msg_lines.length > 1
+			
+			html += "<tr class=\"#{classes.join(" ")}\">"
+			html += "<td>#{log.id}</td>"
+			html += "<td>#{first_line.html}</td>"
+			html += "<td>#{log.date_saved_str}</td>"
+			html += "<td>#{log.objects_html(args[:ob_use])}</td>" if args[:ob_use]
+			html += "</tr>"
+		end
+		
+		if links.empty?
+			html += "<tr>"
+			html += "<td colspan=\"2\" class=\"error\">No logs were found for that object.</td>"
+			html += "</tr>"
+		end
+		
+		html += "</tbody>"
+		html += "</table>"
+		
+		return html
+	end
+end

data/lib/include/class_knjappserver_mailing.rb

@@ -0,0 +1,97 @@
+class Knjappserver
+  attr_reader :mails_waiting
+  
+	def initialize_mailing
+		@mails_waiting = []
+		@mails_mutex = Mutex.new
+		@mails_queue_mutex = Mutex.new
+		@mails_timeout = self.timeout(:time => 10) do
+			self.mail_flush
+		end
+	end
+	
+	def mail(mail_args)
+		@mails_queue_mutex.synchronize do
+			count_wait = 0
+			while @mails_waiting.length > 100
+				if count_wait >= 30
+					raise "Could not send email - too many emails was pending and none of them were being sent?"
+				end
+				
+				count_wait += 1
+				sleep 1
+			end
+			
+			mailobj = Knjappserver::Mail.new({:kas => self, :errors => {}, :status => :waiting}.merge(mail_args))
+			@mails_waiting << mailobj
+			return mailobj
+		end
+	end
+	
+	def mail_flush
+		@mails_mutex.synchronize do
+			return false if @mails_waiting.length <= 0
+			
+			status = Ping.pingecho("google.dk", 10, 80)
+			if !status
+				STDOUT.print "We are not online - skipping mail flush.\n"
+				return false  #Dont run if we dont have a connection to the internet and then properly dont have a connection to the SMTP as well.
+			end
+			
+			@mails_waiting.each do |mail|
+				begin
+					if mail.send
+						@mails_waiting.delete(mail)
+					end
+				rescue Timeout::Error
+					#ignore - 
+				rescue => e
+					@mails_waiting.delete(mail)
+					self.handle_error(e, {:email => false})
+				end
+				
+				sleep 1 #sleep so we dont take up too much bandwidth.
+			end
+		end
+	end
+	
+	class Mail
+		def initialize(args)
+			@args = args
+			
+			raise "No knjappserver-object was given (as :kas)." if !@args[:kas].is_a?(Knjappserver)
+			raise "No :to was given." if !@args[:to]
+			raise "No content was given (:html)." if !@args[:html]
+		end
+		
+		def [](key)
+			return @args[key]
+		end
+		
+		def send
+			mail = Knj::Mailobj.new(@args[:kas].config[:smtp_args])
+			mail.to = @args[:to]
+			mail.subject = @args[:subject] if @args[:subject]
+			mail.html = @args[:html] if @args[:html]
+			
+			if @args[:from]
+				mail.from = @args[:from]
+			else
+				mail.from = @args[:kas].config[:error_report_from]
+			end
+			
+			begin
+				mail.send
+				@args[:status] = :sent
+				return true
+			rescue SocketError => e
+				@args[:errors][e.class.name] = {:count => 0} if !@args[:errors].has_key?(e.class.name)
+				@args[:errors][e.class.name][:count] += 1
+				raise e if @args[:errors][e.class.name][:count] >= 5
+				@args[:status] = :error
+				@args[:error] = e
+				return false
+			end
+		end
+	end
+end

data/lib/include/class_knjappserver_threadding.rb

@@ -0,0 +1,87 @@
+class Knjappserver
+	def initialize_threadding
+    @config[:threadding] = {} if !@config.has_key?(:threadding)
+    @config[:threadding][:max_running] = 25 if !@config[:threadding].has_key?(:max_running)
+    
+		@threadpool = Knj::Threadpool.new(:threads => @config[:threadding][:max_running])
+		@threadpool.events.connect(:on_error) do |event, error|
+      STDOUT.print "Error!\n"
+			self.handle_error(error)
+		end
+	end
+	
+	def thread(args = {})
+		raise "No block given." if !block_given?
+		args[:args] = [] if !args[:args]
+		
+		@threadpool.run_async do
+      @ob.db.get_and_register_thread if @ob.db.opts[:threadsafe]
+      @db_handler.get_and_register_thread if @db_handler.opts[:threadsafe]
+      
+      Thread.current[:knjappserver] = {
+        :kas => self,
+        :db => @db_handler
+      }
+      
+			begin
+				yield(*args[:args])
+			rescue Exception => e
+				handle_error(e)
+			ensure
+				@ob.db.free_thread if @ob.db.opts[:threadsafe]
+				@db_handler.free_thread if @db_handler.opts[:threadsafe]
+			end
+		end
+	end
+	
+	def timeout(args = {})
+		raise "No time given." if !args.has_key?(:time)
+		raise "No block given." if !block_given?
+		args[:args] = [] if !args[:args]
+		
+		thread = Thread.new do
+			loop do
+				begin
+					if args[:counting]
+						Thread.current[:knjappserver_timeout] = args[:time].to_s.to_i
+						
+						while Thread.current[:knjappserver_timeout] > 0
+							Thread.current[:knjappserver_timeout] += -1
+							break if @should_restart
+							sleep 1
+						end
+					else
+						sleep args[:time]
+					end
+					
+					break if @should_restart
+					
+					@threadpool.run do
+            @ob.db.get_and_register_thread if @ob.db.opts[:threadsafe]
+            @db_handler.get_and_register_thread if @db_handler.opts[:threadsafe]
+            
+            Thread.current[:knjappserver] = {
+              :kas => self,
+              :db => @db_handler
+            }
+						
+						begin
+							yield(*args[:args])
+						ensure
+							@ob.db.free_thread if @ob.db.opts[:threadsafe]
+							@db_handler.free_thread if @db_handler.opts[:threadsafe]
+						end
+					end
+				rescue Exception => e
+					handle_error(e)
+				end
+			end
+		end
+		
+		return thread
+	end
+	
+	def threadded_content(&block)
+    _httpsession.threadded_content(block)
+	end
+end

data/lib/include/class_knjappserver_web.rb

@@ -0,0 +1,23 @@
+class Knjappserver
+	def redirect(url, args = {})
+		return Knj::Web.redirect(url, args)
+	end
+	
+	def alert(msg)
+		Knj::Web.alert(msg)
+		return self
+	end
+	
+	def header(key, val)
+    Knj::Php.header("#{key}: #{val}")
+	end
+	
+	def header_raw(str)
+    Knj::Php.header(str)
+	end
+	
+	def back
+		Knj::Web.back
+		return self
+	end
+end

data/lib/include/class_log.rb

@@ -0,0 +1,81 @@
+class Knjappserver::Log < Knj::Datarow
+	def self.list(d)
+		sql = "SELECT #{table}.* FROM #{table}"
+		
+		if d.args["object_lookup"]
+      data_val = d.ob.get_by(:Log_data_value, {"value" => d.args["object_lookup"].class.name})
+      return [] if !data_val #if this data-value cannot be found, nothing has been logged for the object. So just return empty array here and skip the rest.
+      
+			sql += "
+				LEFT JOIN Log_link ON
+					Log_link.log_id = #{table}.id AND
+					Log_link.object_class_value_id = '#{d.db.esc(data_val.id)}' AND
+					Log_link.object_id = '#{d.db.esc(d.args["object_lookup"].id)}'
+			"
+		end
+		
+		sql += " WHERE 1=1"
+		
+		ret = list_helper(d)
+		d.args.each do |key, val|
+			case key
+				when "object_lookup"
+          sql += " AND Log_link.id IS NOT NULL"
+				else
+					raise "Invalid key: #{key}."
+				end
+		end
+		
+		sql += ret[:sql_where]
+		sql += ret[:sql_order]
+		sql += ret[:sql_limit]
+		
+		return d.ob.list_bysql(:Log, sql)
+	end
+	
+	def self.add(d)
+		if !d.data.has_key?(:date_saved)
+			d.data[:date_saved] = d.db.date_out(Knj::Datet.new)
+		end
+	end
+	
+	def text
+		return ob.get(:Log_data_value, self[:text_value_id])[:value]
+	end
+	
+	def get
+		ob.args[:knjappserver].log_data_hash(self[:get_keys_data_id], self[:get_values_data_id])
+	end
+	
+	def post
+		ob.args[:knjappserver].log_data_hash(self[:post_keys_data_id], self[:post_values_data_id])
+	end
+	
+	def first_line
+		lines = self.text.to_s.split("\n").first.to_s
+	end
+	
+	def links(args = {})
+		return ob.list(:Log_link, {"log" => self}.merge(args))
+	end
+	
+	def objects_html(ob_use)
+		html = ""
+		first = true
+		
+		self.links.each do |link|
+			obj = link.object(ob_use)
+			
+			html += ", " if !first
+			first = false if first
+			
+			if obj.respond_to?(:html)
+				html += obj.html
+			else
+				html += "#{obj.class.name}{#{obj.id}}"
+			end
+		end
+		
+		return html
+	end
+end

data/lib/include/class_log_access.rb

@@ -0,0 +1,103 @@
+class Knjappserver::Log_access < Knj::Datarow
+	def self.list(d)
+		sql = "SELECT * FROM #{table} WHERE 1=1"
+		
+		ret = list_helper(d)
+		d.args.each do |key, val|
+			raise "Invalid key: #{key}."
+		end
+		
+		sql += ret[:sql_where]
+		sql += ret[:sql_order]
+		sql += ret[:sql_limit]
+		
+		return d.ob.list_bysql(:Log_access, sql)
+	end
+	
+	def get
+		return data_hash("get")
+	end
+	
+	def post
+		return data_hash("post")
+	end
+	
+	def meta
+		return data_hash("meta")
+	end
+	
+	def cookie
+		return data_hash("cookie")
+	end
+	
+	def ips
+		return data_array(self[:ip_data_id])
+	end
+	
+	def data_array(data_id)
+		sql = "
+			SELECT
+				value_value.value AS value
+			
+			FROM
+				Log_data_link AS value_links,
+				Log_data_value AS value_value
+			
+			WHERE
+				value_links.data_id = '#{data_id}' AND
+				value_value.id = value_links.value_id
+			
+			ORDER BY
+				key_links.no
+		"
+		
+		arr = []
+		q_array = db.query(sql)
+		while d_array = q_array.fetch
+			arr << d_array[:value]
+		end
+		
+		return arr
+	end
+	
+	def data_hash(type)
+		col_keys_id = "#{type}_keys_data_id".to_sym
+		col_values_id = "#{type}_values_data_id".to_sym
+		
+		keys_id = self[col_keys_id]
+		values_id = self[col_values_id]
+		
+		keys_data_obj = ob.get(:Log_data, keys_id)
+		values_data_obj = ob.get(:Log_data, values_id)
+		
+		sql = "
+			SELECT
+				key_value.value AS `key`,
+				value_value.value AS value
+			
+			FROM
+				Log_data_link AS key_links,
+				Log_data_link AS value_links,
+				Log_data_value AS key_value,
+				Log_data_value AS value_value
+			
+			WHERE
+				key_links.data_id = '#{keys_id}' AND
+				value_links.data_id = '#{values_id}' AND
+				key_links.no = value_links.no AND
+				key_value.id = key_links.value_id AND
+				value_value.id = value_links.value_id
+			
+			ORDER BY
+				key_links.no
+		"
+		
+		hash = {}
+		q_hash = db.query(sql)
+		while d_hash = q_hash.fetch
+			hash[d_hash[:key].to_s] = d_hash[:value]
+		end
+		
+		return hash
+	end
+end

data/lib/include/class_log_data.rb

@@ -0,0 +1,42 @@
+class Knjappserver::Log_data < Knj::Datarow
+	def self.list(d)
+		sql = "SELECT * FROM #{table} WHERE 1=1"
+		
+		ret = list_helper(d)
+		d.args.each do |key, val|
+			raise "Invalid key: #{key}."
+		end
+		
+		sql += ret[:sql_where]
+		sql += ret[:sql_order]
+		sql += ret[:sql_limit]
+		
+		return d.ob.list_bysql(:Log_data, sql)
+	end
+	
+	def self.force(d, id_hash)
+		data_obj = d.ob.get_by(:Log_data, {"id_hash" => id_hash})
+		
+		if !data_obj
+			data_obj = d.ob.add(:Log_data, {"id_hash" => id_hash})
+		end
+		
+		return data_obj
+	end
+	
+	def self.force_id(d, id_hash)
+    data = d.db.query("SELECT * FROM Log_data WHERE id_hash = '#{d.db.esc(id_hash)}' LIMIT 1").fetch
+    return data[:id].to_i if data
+    return d.db.insert(:Log_data, {:id_hash => id_hash}, {:return_id => true}).to_i
+	end
+	
+	def self.by_id_hash(d, id_hash)
+    data = d.db.query("SELECT * FROM Log_data WHERE id_hash = '#{d.db.esc(id_hash)}' LIMIT 1").fetch
+    return data[:id].to_i if data
+    return false
+	end
+	
+	def links(args = {})
+		return ob.list(:Log_data_link, {"data" => self}.merge(args))
+	end
+end