knjrbfw 0.0.21 → 0.0.22

data/lib/knj/objects/objects_sqlhelper.rb

@@ -288,7 +288,7 @@ class Knj::Objects
         if match[2] == "not"
           if val.is_a?(Array)
             if val.empty?
-              sql_where << " AND false"
+              #ignore.
             else
               escape_sql = Knj::ArrayExt.join(
                 :arr => val,

data/lib/knj/os.rb

@@ -194,9 +194,13 @@ module Knj::Os
     if self.os == "linux"
       unix_proc = Knj::Unix_proc.find_self
       if unix_proc
-        if match_cmd = unix_proc["cmd"].match(/^(\/usr\/bin\/|)((j|iron|)ruby([\d\.-]+))(\s+|$)/)
+        if match_cmd = unix_proc["cmd"].match(/^(\/usr\/bin\/|)((j|iron|)ruby([\d\.-]*))(\s+|$)/)
           return "#{match_cmd[1]}#{match_cmd[2]}"
+        else
+          raise "Could not match the executed command from the process."
         end
+      else
+        raise "Could not find the self-process."
       end
     end
     

data/lib/knj/php.rb

@@ -966,6 +966,8 @@ module Knj::Php
   def empty(obj)
     if obj.respond_to?("empty?")
       return obj.empty?
+    elsif obj == nil
+      return true
     else
       raise "Dont know how to handle object on 'empty': '#{obj.class.name}'."
     end

data/lib/knj/process_meta.rb

@@ -7,7 +7,10 @@ class Knj::Process_meta
   def initialize(args = {})
     @args = args
     @objects = {}
+    
+    #These variables are used to free memory in the subprocess, by using ObjectSpace#define_finalizer. The Mutex is the avoid problems when writing to the finalize-array multithreadded.
     @finalize = []
+    @finalize_mutex = Mutex.new
     
     if @args["exec_path"]
       exec_path = @args["exec_path"]
@@ -69,22 +72,32 @@ class Knj::Process_meta
   end
   
   def proxy_finalizer(id)
-    @finalize << id
+    @finalize_mutex.synchronize do
+      @finalize << id
+    end
   end
   
   def check_finalizers
     return nil if @finalize.empty?
     
-    remove = []
-    @finalize.each do |id|
-      @process.send("obj" => {
-        "type" => "unset",
-        "var_name" => id
-      })
-      remove << id
+    finalize = nil
+    @finalize_mutex.synchronize do
+      finalize = @finalize
+      @finalize = []
+      
+      begin
+        @process.send("obj" => {
+          "type" => "unset_multiple",
+          "var_names" => finalize
+        })
+      rescue => e
+        if e.message.to_s.index("Var-name didnt exist when trying to unset:")
+          #ignore.
+        else
+          raise e
+        end
+      end
     end
-    
-    @finalize -= remove
   end
   
   #Parses the arguments given. Proxy-object-arguments will be their natural objects in the subprocess.
@@ -184,6 +197,10 @@ class Knj::Process_meta
   
   #Spawns a new object in the subprocess by that classname, with those arguments and with that block.
   def new(class_name, *args, &block)
+    #We need to check finalizers first, so we wont accidently reuse an ID, which will then be unset in the process.
+    self.check_finalizers
+    
+    #Spawn and return the object.
     return self.spawn_object(class_name, nil, *args, &block)
   end
   
@@ -224,19 +241,23 @@ class Knj::Process_meta
   
   #Calls a method on an object and returns the result.
   def call_object(args, &block)
-    self.check_finalizers
-    
     if args.key?("capture_return")
       capture_return = args["capture_return"]
     else
       capture_return = true
     end
     
+    if args["buffered"]
+      type = "call_object_buffered"
+    else
+      type = "call_object_block"
+    end
+    
     res = @process.send(
       {
         "buffer_use" => args["buffer_use"],
         "obj" => {
-          "type" => "call_object_block",
+          "type" => type,
           "var_name" => args["var_name"],
           "method_name" => args["method_name"],
           "capture_return" => capture_return,
@@ -329,7 +350,12 @@ class Knj::Process_meta
     @process.send("obj" => {"type" => "exit"})
     @err_thread.kill if @err_thread
     @process.destroy
-    Process.kill("TERM", @pid)
+    
+    begin
+      Process.kill("TERM", @pid)
+    rescue Errno::ESRCH
+      #Process is already dead - ignore.
+    end
     
     begin
       sleep 0.1
@@ -410,4 +436,113 @@ class Knj::Process_meta::Proxy_obj
       &block
     )
   end
+  
+  def _pm_buffered_caller(args)
+    return Knj::Process_meta::Proxy_obj::Buffered_caller.new({
+      :name => @args[:name],
+      :process_meta => @args[:process_meta]
+    }.merge(args))
+  end
+end
+
+class Knj::Process_meta::Proxy_obj::Buffered_caller
+  def initialize(args)
+    @args = args
+    @buffer = []
+    @mutex = Mutex.new
+    @mutex_write = Mutex.new
+    @count = 0
+    @debug = @args[:debug] if @args[:debug]
+    
+    if @args[:count_to]
+      @count_to = @args[:count_to]
+    else
+      @count_to = 1000
+    end
+    
+    @buffer_max = @count_to * 2
+    @threads = [] if @args[:async]
+  end
+  
+  def method_missing(method_name, *args)
+    if method_name.to_s == @args[:method_name].to_s
+      self._pm_call(*args)
+    else
+      raise NoMethodError, "No such method: '#{method_name}'."
+    end
+  end
+  
+  def _pm_call(*args)
+    raise @raise_error if @raise_error
+    
+    @mutex.synchronize do
+      while @count >= @count_to and @buffer.length >= @buffer_max
+        STDOUT.print "Waiting for write to complete...\n" if @debug
+        sleep 0.1
+      end
+      
+      STDOUT.print "Adding to buffer #{@buffer.length}...\n" if @debug
+      @buffer << args
+      @count += 1
+    end
+    
+    self._pm_flush if @count >= @count_to and !@writing
+    return nil
+  end
+  
+  def _pm_flush(*args)
+    raise @raise_error if @raise_error
+    
+    buffer = nil
+    @mutex.synchronize do
+      buffer = @buffer
+      @buffer = []
+      @count = 0
+    end
+    
+    if @args[:async]
+      begin
+        @threads << Thread.new do
+          self._pm_flush_real(buffer)
+        end
+      rescue => e
+        @raise_error = e
+      end
+      
+      return nil
+    else
+      return self._pm_flush_real(buffer)
+    end
+  end
+  
+  def _pm_flush_real(buffer)
+    @mutex_write.synchronize do
+      STDOUT.print "Writing...\n" if @debug
+      @writing = true
+      
+      begin
+        return @args[:process_meta].call_object(
+          "var_name" => @args[:name],
+          "method_name" => @args[:method_name],
+          "args" => buffer,
+          "buffered" => true,
+          "capture_return" => false
+        )
+      ensure
+        @writing = false
+      end
+    end
+  end
+  
+  def _pm_close
+    self._pm_flush
+    
+    if @args[:async]
+      @threads.each do |thread|
+        thread.join
+      end
+    end
+    
+    raise @raise_error if @raise_error
+  end
 end

data/lib/knj/scripts/process_meta_exec.rb

@@ -22,6 +22,8 @@ objects = {}
     
     if obj.is_a?(Hash)
       if obj["type"] == "spawn_object"
+        raise "An object by that name already exists: '#{obj["var_name"]}'." if objects.key?(obj["var_name"])
+        
         #Fix new integer.
         if obj["class_name"].to_s == "Integer" or obj["class_name"].to_s == "Fixnum"
           objects[obj["var_name"]] = obj["args"].first.to_i
@@ -35,7 +37,7 @@ objects = {}
         d.answer("type" => "success")
       elsif obj["type"] == "proxy_from_call"
         raise "No 'var_name' was given in arguments." if !obj["var_name"]
-        raise "No object by that name: '#{obj["proxy_obj"]}' in '#{objects}'." if !objects.key?(obj["proxy_obj"])
+        raise "No object by that name when trying to do 'proxy_from_call': '#{obj["proxy_obj"]}' in '#{objects}'." if !objects.key?(obj["proxy_obj"])
         obj_to_call = objects[obj["proxy_obj"]]
         res = obj_to_call.__send__(obj["method_name"], *obj["args"])
         objects[obj["var_name"]] = res
@@ -57,6 +59,28 @@ objects = {}
         raise "No object by that name: '#{obj["var_name"]}'." if !obj
         res = obj_to_call.__send__(obj["method_name"], *obj["args"])
         res = nil if obj["capture_return"] == false
+        d.answer("type" => "call_object_success", "result" => res)
+      elsif obj["type"] == "call_object_buffered"
+        raise "Invalid var-name: '#{obj["var_name"]}'." if obj["var_name"].to_s.strip.length <= 0
+        
+        obj_to_call = objects[obj["var_name"]]
+        raise "No object by that name: '#{obj["var_name"]}'." if !obj
+        capt_return = obj["capture_return"]
+        
+        if capt_return != false
+          ret = []
+        else
+          ret = nil
+        end
+        
+        obj["args"].each do |args|
+          if capt_return != false
+            ret << obj_to_call.__send__(obj["method_name"], *args)
+          else
+            obj_to_call.__send__(obj["method_name"], *args)
+          end
+        end
+        
         d.answer("type" => "call_object_success", "result" => res)
       elsif obj["type"] == "call_object_block"
         raise "Invalid var-name: '#{obj["var_name"]}'." if obj["var_name"].to_s.strip.length <= 0
@@ -77,9 +101,19 @@ objects = {}
         end
       elsif obj["type"] == "unset"
         raise "Invalid var-name: '#{obj["var_name"]}'." if obj["var_name"].to_s.strip.length <= 0
-        raise "Var-name doesnt exist: '#{obj["var_name"]}'." if !objects.key?(obj["var_name"])
+        raise Knj::Errors::NotFound, "Var-name didnt exist when trying to unset: '#{obj["var_name"]}'." if !objects.key?(obj["var_name"])
         objects.delete(obj["var_name"])
         d.answer("type" => "unset_success")
+      elsif obj["type"] == "unset_multiple"
+        err = nil
+        obj["var_names"].each do |var_name|
+          err = [Knj::Errors::InvalidData, "Invalid var-name: '#{var_name}'."] if var_name.to_s.strip.length <= 0
+          err = [Knj::Errors::NotFound, "Var-name didnt exist when trying to unset: '#{var_name}'."] if !objects.key?(var_name)
+          objects.delete(var_name)
+        end
+        
+        raise err[0], err[1] if err
+        d.answer("type" => "unset_success")
       elsif obj["type"] == "static"
         const = Knj::Strings.const_get_full(obj["const"])
         res = const.__send__(obj["method_name"], *obj["args"], &block)

data/lib/knj/unix_proc.rb

@@ -1,17 +1,23 @@
+require "#{$knjpath}wref"
+
 class Knj::Unix_proc
   attr_reader :data
-  @procs = {}
+  
+  PROCS = Knj::Wref_map.new
+  MUTEX = Mutex.new
   
   def self.spawn(data)
-    proc_ele = @procs[data["pid"]]
+    pid = data["pid"].to_i
     
-    if proc_ele
+    begin
+      proc_ele = PROCS[pid]
       proc_ele.update_data(data)
-    else
-      @procs[data["pid"]] = Knj::Unix_proc.new(data)
+    rescue WeakRef::RefError
+      proc_ele = Knj::Unix_proc.new(data)
+      PROCS[pid] = proc_ele
     end
     
-    return @procs[data["pid"]]
+    return proc_ele
   end
   
   def self.list(args = {})
@@ -23,40 +29,43 @@ class Knj::Unix_proc
       cmdstr << " | #{grepstr}"
     end
     
-    ret = []
-    res = Knj::Os.shellcmd(cmdstr)
-    
-    res.scan(/^(\S+)\s+([0-9]+)\s+([0-9.]+)\s+([0-9.]+)\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+ (.+)($|\n)/) do |match|
-      pid = match[1]
-      
-      data = {
-        "user" => match[0],
-        "pid" => pid,
-        "cpu_last" => match[2],
-        "ram_last" => match[3],
-        "cmd" => match[4],
-        "app" => File.basename(match[4])
-      }
-      
-      next if (!args.key?("ignore_self") or args["ignore_self"]) and match[1].to_i == $$.to_i
-      next if grepstr.length > 0 and match[4].index(grepstr) != nil #dont return current process.
+    MUTEX.synchronize do
+      ret = []
+      res = Knj::Os.shellcmd(cmdstr)
       
-      if args.key?("pids")
-        found = false
-        args["pids"].each do |pid_given|
-          if pid_given.to_s == pid.to_s
-            found = true
-            break
+      res.scan(/^(\S+)\s+([0-9]+)\s+([0-9.]+)\s+([0-9.]+)\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+ (.+)($|\n)/) do |match|
+        pid = match[1]
+        
+        data = {
+          "user" => match[0],
+          "pid" => pid,
+          "cpu_last" => match[2],
+          "ram_last" => match[3],
+          "cmd" => match[4],
+          "app" => File.basename(match[4])
+        }
+        
+        next if (!args.key?("ignore_self") or args["ignore_self"]) and match[1].to_i == $$.to_i
+        next if grepstr.length > 0 and match[4].index(grepstr) != nil #dont return current process.
+        
+        if args.key?("pids")
+          found = false
+          args["pids"].each do |pid_given|
+            if pid_given.to_s == pid.to_s
+              found = true
+              break
+            end
           end
+          
+          next if !found
         end
         
-        next if !found
+        ret << Knj::Unix_proc.spawn(data)
       end
       
-      ret << Knj::Unix_proc.spawn(data)
+      PROCS.clean
+      return ret
     end
-    
-    return ret
   end
   
   def self.find_self

data/lib/knj/web.rb

@@ -466,7 +466,7 @@ class Knj::Web
     Knj::ArrayExt.hash_sym(args)
     
     if args.key?(:value)
-      if args[:value].is_a?(Array) and args[:value].first.is_a?(NilClass)
+      if args[:value].is_a?(Array) and (args[:value].first.is_a?(NilClass) or args[:value].first == false)
         value = nil
       elsif args[:value].is_a?(Array)
         if !args[:value][2] or args[:value][2] == :key
@@ -530,6 +530,7 @@ class Knj::Web
     }
     attr.merge!(args[:attr]) if args[:attr]
     attr["disabled"] = "disabled" if args[:disabled]
+    attr["maxlength"] = args[:maxlength] if args.key?(:maxlength)
     
     raise "No name given to the Web::input()-method." if !args[:name] and args[:type] != :info and args[:type] != :textshow and args[:type] != :plain and args[:type] != :spacer and args[:type] != :headline
     
@@ -553,6 +554,12 @@ class Knj::Web
       classes_tr_html = ""
     end
     
+    if args.key?(:title)
+      title_html = args[:title].to_s.html
+    elsif args.key?(:title_html)
+      title_html = args[:title_html]
+    end
+    
     html = ""
     
     classes = ["input_#{args[:type]}"]
@@ -567,17 +574,17 @@ class Knj::Web
       html << "<tr#{classes_tr_html}>"
       html << "<td colspan=\"2\" class=\"tdcheck\">"
       html << "<input#{self.attr_html(attr)} />"
-      html << "<label for=\"#{args[:id].html}\">#{args[:title].html}</label>"
+      html << "<label for=\"#{args[:id].html}\">#{title_html}</label>"
       html << "</td>"
       html << "</tr>"
     elsif args[:type] == :headline
-      html << "<tr#{classes_tr_html}><td colspan=\"2\"><h2 class=\"input_headline\">#{args[:title].html}</h2></td></tr>"
+      html << "<tr#{classes_tr_html}><td colspan=\"2\"><h2 class=\"input_headline\">#{title_html}</h2></td></tr>"
     elsif args[:type] == :spacer
       html << "<tr#{classes_tr_html}><td colspan=\"2\">&nbsp;</td></tr>"
     else
       html << "<tr#{classes_tr_html}>"
       html << "<td class=\"tdt\">"
-      html << args[:title].to_s.html
+      html << title_html
       html << "</td>"
       html << "<td#{self.style_html(css)} class=\"tdc\">"
       
@@ -671,12 +678,7 @@ class Knj::Web
   
   def self.opts(opthash, curvalue = nil, opts_args = {})
     opts_args = {} if !opts_args
-    opts_args.each do |key, value|
-      if !key.is_a?(Symbol)
-        opts_args[key.to_sym] = value
-        opts_args.delete(key)
-      end
-    end
+    Knj::ArrayExt.hash_sym(opts_args)
     
     return "" if !opthash
     cname = curvalue.class.name
@@ -739,7 +741,7 @@ class Knj::Web
       return "gecko"
     elsif agent.index("msie") != nil
       return "msie"
-    elsif agent.index("w3c") != nil or agent.index("baiduspider") != nil or agent.index("googlebot") != nil
+    elsif agent.index("w3c") != nil or agent.index("baiduspider") != nil or agent.index("googlebot") != nil or agent.index("bot") != nil
       return "bot"
     else
       #print "Unknown agent: #{agent}"
@@ -887,16 +889,36 @@ class Knj::Web
       browser = "bot"
       title = "AhrefsBot"
       version = match[1]
+    elsif agent.index("sosospider") != nil
+      browser = "bot"
+      title = "Bot"
+      version = "Sosospider"
     else
       browser = "unknown"
       title = "(unknown browser)"
       version = "(unknown version)"
     end
     
+    os = nil
+    os_version = nil
+    if agent.index("linux") != nil
+      os = "linux"
+    elsif match = agent.match(/mac\s+os\s+x\s+([\d_+])/)
+      os = "mac"
+    elsif match = agent.match(/windows\s+nt\s+([\d\.]+)/)
+      os = "windows"
+      
+      if match[1] == "5.1"
+        os_version = "xp"
+      end
+    end
+    
     return {
       "browser" => browser,
       "title" => title,
-      "version" => version
+      "version" => version,
+      "os" => os,
+      "os_version" => os_version
     }
   end