knjappserver 0.0.15 → 0.0.16

data/lib/include/class_knjappserver_cleaner.rb

@@ -13,7 +13,8 @@ class Knjappserver
         
         if @config.has_key?(:restart_when_used_memory) and !@should_restart
           mbs_used = (Knj::Php.memory_get_usage / 1024) / 1024
-          #STDOUT.print "Used: #{mbs_used}\n"
+          STDOUT.print "Restart when over #{@config[:restart_when_used_memory]}mb\n" if @config[:debug]
+          STDOUT.print "Used: #{mbs_used}mb\n" if @config[:debug]
           
           if mbs_used.to_i >= @config[:restart_when_used_memory].to_i
             STDOUT.print "Memory is over #{@config[:restart_when_used_memory]} - restarting.\n"
@@ -25,7 +26,7 @@ class Knjappserver
           begin
             @should_restart_runnning = true
             
-            #When we begin to restart it should go as fast as possible - so start by flushing out any emails waiting...
+            #When we begin to restart it should go as fast as possible - so start by flushing out any emails waiting so it goes faster the last time...
             STDOUT.print "Flushing mails.\n"
             self.mail_flush
             
@@ -89,19 +90,25 @@ class Knjappserver
       STDOUT.print "Cleaning sessions on appserver.\n" if @config[:debug]
       
       self.paused_exec do
+        session_not_ids = []
         time_check = Time.now.to_i - 300
-        @sessions.each do |ip, ip_sessions|
-          ip_sessions.each do |session_hash, session_data|
-            if session_data[:time_lastused].to_i <= time_check
-              session_data[:dbobj].flush
-              @ob.unset(session_data[:dbobj])
-              session_data[:hash].clear
-              ip_sessions.delete(session_hash)
-              session_data.clear
-            end
-          end
+        newsessions = {}
+        @sessions.each do |session_hash, session_data|
+          session_data[:dbobj].flush
           
-          @sessions.delete(ip) if ip_sessions.empty?
+          if session_data[:time_lastused].to_i > time_check
+            newsessions[session_hash] = session_data
+            session_not_ids << session_data[:dbobj].id
+          end
+        end
+        
+        @sessions = newsessions
+        
+        STDOUT.print "Delete sessions...\n" if @config[:debug]
+        @ob.list(:Session, {"id_not" => session_not_ids, "date_lastused_below" => (Time.now - 5356800)}) do |session|
+          @ob.delete(session)
+          @sessions.delete(session[:idhash])
+          STDOUT.print "Deleted session: #{session.id}\n" if @config[:debug]
         end
       end
     end

data/lib/include/class_knjappserver_cmdline.rb

@@ -0,0 +1,44 @@
+class Knjappserver
+  def initialize_cmdline
+    @cmds = {}
+    
+    Knj::Thread.new do
+      line = $stdin.gets
+      
+      called = 0
+      @cmds.each do |key, connects|
+        data = {}
+        
+        if key.is_a?(Regexp)
+          if line.match(key)
+            connects.each do |conn|
+              called += 1
+              conn[:block].call(data)
+            end
+          end
+        else
+          raise "Unknown class for 'cmd_connect': '#{key.class.name}'."
+        end
+      end
+      
+      if called == 0
+        print "Unknown command: '#{line.strip}'.\n"
+      end
+    end
+    
+    self.cmd_connect(/^\s*restart\s*$/i) do |data|
+      print "Restart will begin shortly.\n"
+      self.should_restart = true
+    end
+    
+    self.cmd_connect(/^\s*stop\s*$/i) do |data|
+      self.stop
+    end
+  end
+  
+  #Connects a proc to a specific command in the command-line (key should be a regex).
+  def cmd_connect(cmd, &block)
+    @cmds[cmd] = [] if !@cmds.key?(cmd)
+    @cmds[cmd] << {:block => block}
+  end
+end

data/lib/include/class_knjappserver_errors.rb

@@ -18,6 +18,7 @@ class Knjappserver
 		end
 	end
 	
+	#Send error-emails based on error-emails-cache (cached so the same error isnt send out every time it occurrs to prevent spamming).
 	def flush_error_emails
 		@error_emails_pending_mutex.synchronize do
 			send_time_older_than = Time.new.to_i - @error_emails_time
@@ -65,6 +66,7 @@ class Knjappserver
 		end
 	end
 	
+	#Handels a given error. Sends to the admin-emails.
 	def handle_error(e, args = {})
 		@error_emails_pending_mutex.synchronize do
 			if !Thread.current[:knjappserver] or !Thread.current[:knjappserver][:httpsession]
@@ -82,7 +84,7 @@ class Knjappserver
 					@error_emails_pending[backtrace_hash] = {
 						:first_time => Time.new,
 						:messages => [],
-						:subject => sprintf("Error @ %s", @config[:title]) + " (#{e.message})"
+						:subject => sprintf("Error @ %s", @config[:title]) + " (#{Knj::Strings.shorten(e.message, 100)})"
 					}
 				end
 				
@@ -107,6 +109,7 @@ class Knjappserver
 		end
 	end
 	
+	#Takes a proc and executes it. On error it alerts the error-message with javascript to the server, sends a javascript back and exits.
 	def on_error_go_back(&block)
     begin
       block.call

data/lib/include/class_knjappserver_logging.rb

@@ -12,6 +12,7 @@ class Knjappserver
 		end
 	end
 	
+	#Writes all queued access-logs to the database.
 	def flush_access_log
 		@logs_mutex.synchronize do
 			ins_arr = @logs_access_pending
@@ -155,8 +156,12 @@ class Knjappserver
 	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)
+    begin
+      keys_data_obj = @ob.get(:Log_data, keys_id)
+      values_data_obj = @ob.get(:Log_data, values_id)
+    rescue Knj::Errors::NotFound
+      return {}
+    end
 		
 		sql = "
 			SELECT
@@ -181,20 +186,20 @@ class Knjappserver
 		"
 		
 		hash = {}
-		q_hash = db.query(sql)
-		while d_hash = q_hash.fetch
+		db.q(sql) do |d_hash|
 			hash[d_hash[:key].to_sym] = d_hash[:value]
 		end
 		
 		return hash
 	end
 	
-	def log(msg, objs)
+	#Writes a custom log to the database.
+	def log(msg, objs, args = {})
 		@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,
+				:date_saved => Time.now,
 				:text_value_id => log_value_id
 			}
 			
@@ -210,6 +215,28 @@ class Knjappserver
 				ins_data[:post_values_data_id] = post_hash[:values_data_id]
 			end
 			
+			cookie_hash = log_hash_ins(_cookie) if _cookie
+			if cookie_hash
+        ins_data[:post_keys_data_id] = cookie_hash[:keys_data_id]
+        ins_data[:post_values_data_id] = cookie_hash[:values_data_id]
+			end
+			
+			meta_hash = log_hash_ins(_meta) if _meta
+      if cookie_hash
+        ins_data[:meta_keys_data_id] = meta_hash[:keys_data_id]
+        ins_data[:meta_values_data_id] = meta_hash[:values_data_id]
+      end
+      
+      if args[:tag]
+        tag_value_id = @ob.static(:Log_data_value, :force_id, args[:tag])
+        ins_data[:tag_data_id] = tag_value_id
+      end
+      
+      if args[:comment]
+        comment_value_id = @ob.static(:Log_data_value, :force_id, args[:comment])
+        ins_data[:comment_data_id] = comment_value_id
+      end
+			
 			log_id = @db.insert(:Log, ins_data, {:return_id => true})
 			
 			log_links = []
@@ -227,6 +254,7 @@ class Knjappserver
 		end
 	end
 	
+	#Returns the HTML for a table with logs from a given object.
 	def logs_table(obj, args = {})
 		links = @ob.list(:Log_link, {"object_class" => obj.class.name, "object_id" => obj.id, "limit" => 500, "orderby" => [["id", "desc"]]})
 		
@@ -235,8 +263,10 @@ class Knjappserver
 		html += "<tr>"
 		html += "<th>ID</th>"
 		html += "<th>Message</th>"
-		html += "<th>Date &amp; time</th>"
+		html += "<th style=\"width: 130px;\">Date &amp; time</th>"
+		html += "<th>Tag</th>"
 		html += "<th>Objects</th>" if args[:ob_use]
+		html += "<th>IP</th>" if args[:show_ip]
 		html += "</tr>"
 		html += "</thead>"
 		html += "<tbody>"
@@ -254,7 +284,17 @@ class Knjappserver
 			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 += "<td>#{log.tag.html}</td>"
+			
+			if args[:ob_use]
+        begin
+          html += "<td>#{log.objects_html(args[:ob_use])}</td>"
+        rescue => e
+          html += "<td>#{e.message.html}</td>"
+        end
+      end
+      
+			html += "<td>#{log.ip}</td>" if args[:show_ip]
 			html += "</tr>"
 		end
 		

data/lib/include/class_knjappserver_mailing.rb

@@ -2,6 +2,9 @@ class Knjappserver
   attr_reader :mails_waiting
   
 	def initialize_mailing
+    STDOUT.print "Loading mail.\n" if @config[:debug]
+    require "mail" if !@config.has_key?(:mail_require) or @config[:mail_require]
+    
 		@mails_waiting = []
 		@mails_mutex = Mutex.new
 		@mails_queue_mutex = Mutex.new
@@ -10,6 +13,7 @@ class Knjappserver
 		end
 	end
 	
+	#Queue a mail for sending. Possible keys are: :subject, :from, :to, :text and :html.
 	def mail(mail_args)
 		@mails_queue_mutex.synchronize do
 			count_wait = 0
@@ -23,11 +27,13 @@ class Knjappserver
 			end
 			
 			mailobj = Knjappserver::Mail.new({:kas => self, :errors => {}, :status => :waiting}.merge(mail_args))
+			STDOUT.print "Added mail '#{mailobj.__id__}' to the mail-send-queue.\n" if debug
 			@mails_waiting << mailobj
 			return mailobj
 		end
 	end
 	
+	#Sends all queued mails to the respective servers, if we are online.
 	def mail_flush
 		@mails_mutex.synchronize do
 			return false if @mails_waiting.length <= 0
@@ -55,41 +61,57 @@ class Knjappserver
 		end
 	end
 	
+	#This class represents the queued mails.
 	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]
+      raise "No content was given (:html or :text)." if !@args[:html] and !@args[:text]
 		end
 		
+		#Returns a key from the arguments.
 		def [](key)
 			return @args[key]
 		end
 		
+		#Sends the email to the receiver.
 		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
+      STDOUT.print "Sending mail '#{__id__}'.\n" if @args[:kas].debug
+      
+      begin
+        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]
+        mail.text = @args[:text] if @args[:text]
+        
+        if @args[:from]
+          mail.from = @args[:from]
+        elsif @args[:kas].config[:error_report_from]
+          mail.from = @args[:kas].config[:error_report_from]
+        else
+          raise "Dont know where to take the 'from'-paramter from - none given in appserver config or mail-method-arguments?"
+        end
+        
 				mail.send
 				@args[:status] = :sent
+				STDOUT.print "Sent email #{self.__id__}\n" if @args[:kas].debug
 				return true
-			rescue SocketError => e
+			rescue Exception => e
+        if @args[:kas].debug
+          STDOUT.print "Could not send email.\n"
+          STDOUT.puts e.inspect
+          STDOUT.puts e.backtrace
+        end
+        
 				@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

data/lib/include/class_knjappserver_sessions.rb

@@ -0,0 +1,78 @@
+class Knjappserver
+  def initialize_sessions
+    @sessions = {}
+  end
+  
+  #Returns or adds session based on idhash and meta-data.
+  def session_fromid(args)
+    ip = args[:ip].to_s
+    idhash = args[:idhash].to_s
+    ip = "bot" if idhash == "bot"
+    
+    if !@sessions.key?(idhash)
+      session = @ob.get_by(:Session, {"idhash" => idhash})
+      if !session
+        session = @ob.add(:Session, {
+          :idhash => idhash,
+          :user_agent => args[:meta]["HTTP_USER_AGENT"],
+          :ip => ip
+        })
+      end
+      
+      @sessions[idhash] = {
+        :dbobj => session,
+        :hash => {}
+      }
+    else
+      session = @sessions[idhash][:dbobj]
+    end
+    
+=begin
+    if ip != "bot"
+      if session[:user_agent] != args[:meta]["HTTP_USER_AGENT"]
+        STDOUT.print "Invalid user-agent!\n"
+        STDOUT.print Knj::Php.print_r(session, true)
+        
+        raise Knj::Errors::InvalidData, "Invalid user-agent."
+      elsif !session.remember? and ip.to_s != session[:ip].to_s
+        STDOUT.print "Invalid IP!\n"
+        STDOUT.print Knj::Php.print_r(session, true)
+        
+        raise Knj::Errors::InvalidData, "Invalid IP."
+      end
+    end
+=end
+    
+    @sessions[idhash][:time_lastused] = Time.now
+    return @sessions[idhash]
+  end
+  
+  #Generates a new session-ID by the meta data.
+  def session_generate_id(args)
+    meta = args[:meta]
+    return Digest::MD5.hexdigest("#{Time.now.to_f}_#{meta["HTTP_HOST"]}_#{meta["REMOTE_HOST"]}_#{meta["HTTP_X_FORWARDED_SERVER"]}_#{meta["HTTP_X_FORWARDED_FOR"]}_#{meta["HTTP_X_FORWARDED_HOST"]}_#{meta["REMOTE_ADDR"]}_#{meta["HTTP_USER_AGENT"]}")
+  end
+  
+  #Will make the session rememberable for a year. IP wont be checked any more.
+  def session_remember
+    session = _httpsession.session
+    session[:remember] = 1
+    
+    self.cookie(
+      "name" => "KnjappserverSession",
+      "value" => _httpsession.session_id,
+      "path" => "/",
+      "expires" => Time.now + 32140800 #add around 12 months
+    )
+  end
+  
+  #Writes all session-data to the database (normally it is cached in memory and not updated on change).
+  def sessions_flush
+    if @sessions
+      @sessions.each do |session_hash, session_data|
+        STDOUT.print "Flushing session: #{session_data[:dbobj].id}\n" if @debug
+        session_data[:dbobj].flush
+      end
+    end
+  end
+end

data/lib/include/class_knjappserver_threadding.rb

@@ -10,6 +10,13 @@ class Knjappserver
 		end
 	end
 	
+	#Inits the thread so it has access to the appserver and various magic methods can be used.
+	def thread_init(thread)
+    thread[:knjappserver] = {} if !thread[:knjappserver]
+    thread[:knjappserver][:kas] = self
+	end
+	
+	#Spawns a new thread with access to magic methods, _db-method and various other stuff in the appserver.
 	def thread(args = {})
 		raise "No block given." if !block_given?
 		args[:args] = [] if !args[:args]
@@ -34,53 +41,19 @@ class Knjappserver
 		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
+	#Runs a proc every number of seconds.
+	def timeout(args = {}, &block)
+    to = Knjappserver::Threadding_timeout.new(
+      :kas => self,
+      :block => block,
+      :args => args
+    )
+    to.start
+    
+    return to
 	end
 	
+	#Spawns a thread to run the given proc and add the output of that block in the correct order to the HTML.
 	def threadded_content(&block)
     _httpsession.threadded_content(block)
 	end