knjrbfw 0.0.3

data/lib/knj/threadpool.rb

@@ -0,0 +1,177 @@
+class Knj::Threadpool
+	attr_reader :workers, :blocks, :mutex, :args, :events
+	
+	def initialize(args = {})
+		@args = args
+		@args[:sleep] = 0.01 if !@args.has_key?(:sleep)
+		@workers = []
+		@blocks = []
+		@mutex = Mutex.new
+		@events = Knj::Event_handler.new
+		@events.add_event(:name => :on_error)
+		
+		self.start
+	end
+	
+	def start
+    @mutex.synchronize do
+      if !@running
+        @workers.length.upto(@args[:threads]) do |count|
+          @workers << Knj::Threadpool::Worker.new(:threadpool => self, :id => count)
+        end
+        
+        @running = true
+      end
+    end
+	end
+	
+	def stop
+    if @running
+      @workers.each do |worker|
+        if !worker.running
+          worker.kill
+          @workers.delete(worker)
+        end
+      end
+      
+      @running = false
+    end
+	end
+	
+	def run(*args, &block)
+		raise "No block given." if !block_given?
+		blockdata = {:block => block, :result => nil, :running => false, :runned => false, :args => args}
+		@blocks << blockdata
+		
+		loop do
+			sleep @args[:sleep]
+			
+			if blockdata[:runned]
+				begin
+					res = blockdata[:result]
+					raise blockdata[:error] if blockdata.has_key?(:error)
+				ensure
+					@mutex.synchronize do
+						blockdata.clear
+						@blocks.delete(blockdata)
+					end
+				end
+				
+				return res
+			end
+		end
+	end
+	
+	def run_async(*args, &block)
+		raise "No block given." if !block_given?
+		
+		@mutex.synchronize do
+			blockdata = {:block => block, :running => false, :runned => false, :args => args}
+			@blocks << blockdata
+		end
+	end
+	
+	def get_block
+    return false if !@running
+    
+		@mutex.synchronize do
+			@blocks.each do |blockdata|
+				if !blockdata[:running] and !blockdata[:runned]
+					blockdata[:running] = true
+					return blockdata
+				end
+			end
+			
+			return false
+		end
+	end
+end
+
+class Knj::Threadpool::Worker
+  attr_reader :running
+  
+	def initialize(args)
+		@args = args
+		@tp = @args[:threadpool]
+		@mutex_tp = @tp.mutex
+		@sleep = @tp.args[:sleep]
+		@running = false
+		
+		@thread = Knj::Thread.new do
+			loop do
+				if !@blockdata
+					sleep @sleep
+					@blockdata = @tp.get_block if !@blockdata
+				end
+				
+				next if !@blockdata
+				
+				res = nil
+				raise "No block in blockdata?" if !@blockdata[:block]
+				
+				if @blockdata.has_key?(:result)
+					begin
+            @running = true
+						res = @blockdata[:block].call(*@blockdata[:args])
+					rescue Exception => e
+						@mutex_tp.synchronize do
+							@blockdata[:error] = e
+						end
+					ensure
+            @running = false
+            
+						@mutex_tp.synchronize do
+							@blockdata[:result] = res
+							@blockdata[:runned] = true
+							@blockdata[:running] = false
+						end
+						
+						#Try to avoid slowdown of sleep by checking if there is a new block right away.
+						@blockdata = @tp.get_block
+					end
+				else
+					begin
+						@blockdata[:block].call(*@blockdata[:args])
+					rescue Exception => e
+						if @tp.events.connected?(:on_error)
+							@tp.events.call(:on_error, e)
+						else
+							puts e.inspect
+							puts e.backtrace
+						end
+					ensure
+						@mutex_tp.synchronize do
+							@blockdata.clear
+							@tp.blocks.delete(@blockdata)
+						end
+						
+						#Try to avoid slowdown of sleep by checking if there is a new block right away.
+						@blockdata = @tp.get_block
+					end
+				end
+			end
+		end
+	end
+	
+	def busy?
+		return true if @blockdata
+	end
+	
+	def id
+		return @args[:id]
+	end
+	
+	def kill
+    return false if !@mutex_tp
+    
+    @mutex_tp.synchronize do
+      @thread.kill
+      @args = nil
+      @tp = nil
+      @mutex_tp = nil
+      @sleep = nil
+      @blockdata = nil
+      @thread = nil
+    end
+	end
+end

data/lib/knj/translations.rb

@@ -0,0 +1,139 @@
+class Knj::Translations
+	attr_accessor :args, :db, :ob, :cache
+	
+	def initialize(args)
+		@args = args
+		@cache = {}
+		
+		raise "No DB given." if !@args[:db]
+		@db = @args[:db]
+		
+		@ob = Knj::Objects.new(
+			:db => @args[:db],
+			:extra_args => [self],
+			:class_path => File.dirname(__FILE__),
+			:module => Knj::Translations,
+			:require => false,
+			:datarow => true
+		)
+	end
+	
+	def get(obj, key, args = {})
+		return "" if !obj
+		
+		if args[:locale]
+			locale = args[:locale]
+		else
+			locale = @args[:locale]
+		end
+		
+		classn = obj.class.name
+		objid = obj.id.to_s
+		
+		if @cache[classn] and @cache[classn][objid] and @cache[classn][objid][key] and @cache[classn][objid][key][locale]
+			return @cache[classn][objid][key][locale][:value]
+		end
+		
+		trans = @ob.list(:Translation, {
+			"object_class" => classn,
+			"object_id" => objid,
+			"key" => key,
+			"locale" => locale
+		})
+		return "" if trans.empty?
+		
+		trans.each do |tran|
+			if !@cache.has_key?(classn)
+				@cache[classn] = {
+					objid => {
+						key => {
+							locale => tran
+						}
+					}
+				}
+			elsif !@cache[classn][objid]
+				@cache[classn][objid] = {
+					key => {
+						locale => tran
+					}
+				}
+			elsif !@cache[classn][objid][key]
+				@cache[classn][objid][key] = {
+					locale => tran
+				}
+			elsif !@cache[classn][objid][key][locale]
+				@cache[classn][objid][key][locale] = tran
+			end
+		end
+		
+		return trans[0][:value]
+	end
+	
+	def set(obj, values, args = {})
+		if args[:locale]
+			locale = args[:locale]
+		else
+			locale = @args[:locale]
+		end
+		
+		values.each do |key, val|
+			trans = @ob.get_by(:Translation, {
+				"object_id" => obj.id,
+				"object_class" => obj.class.name,
+				"key" => key,
+				"locale" => locale
+			})
+			
+			if trans
+				trans.update(:value => val)
+			else
+				@ob.add(:Translation, {
+					:object => obj,
+					:key => key,
+					:locale => locale,
+					:value => val
+				})
+			end
+		end
+	end
+	
+	def delete(obj)
+		classn = obj.class.name
+		objid = obj.id.to_s
+		
+		trans = @ob.list(:Translation, {
+			"object_id" => obj.id,
+			"object_class" => obj.class.name
+		})
+		trans.each do |tran|
+			@ob.delete(tran)
+		end
+		
+		@cache[classn].delete(objid) if @cache.has_key?(classn) and @cache.has_key?(objid)
+	end
+end
+
+class Knj::Translations::Translation < Knj::Datarow
+	def self.add(d)
+		if d.data[:object]
+			d.data[:object_class] = d.data[:object].class.name
+			d.data[:object_id] = d.data[:object].id
+			d.data.delete(:object)
+		end
+	end
+	
+	def self.list(d)
+		sql = "SELECT * FROM #{d.db.escape_col}#{d.db.esc_col(table)}#{d.db.escape_col} WHERE 1=1"
+		ret = list_helper(d)
+		
+		d.args.each do |key, val|
+			raise "No such key: #{key}."
+		end
+		
+		sql += ret[:sql_where]
+		sql += ret[:sql_order]
+		sql += ret[:sql_limit]
+		
+		return d.ob.list_bysql(:Translation, sql)
+	end
+end

data/lib/knj/unix_proc.rb

@@ -0,0 +1,82 @@
+class Knj::Unix_proc
+	attr_reader :data
+	@procs = {}
+	
+	def self.spawn(data)
+		proc_ele = @procs[data["pid"]]
+		
+		if proc_ele
+			proc_ele.update_data(data)
+		else
+			@procs[data["pid"]] = Knj::Unix_proc.new(data)
+		end
+		
+		return @procs[data["pid"]]
+	end
+	
+	def self.list(args = {})
+		cmdstr = "ps aux"
+		grepstr = ""
+		
+		if args["grep"]
+			grepstr = "grep #{Knj::Strings.unixsafe(args["grep"])}"
+			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.has_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.
+			next if args.has_key?("pids") and args["pids"].index(pid) == nil
+			
+			ret << Knj::Unix_proc.spawn(data)
+		end
+		
+		return ret
+	end
+	
+	def self.find_self
+		procs = Knj::Unix_proc.list("ignore_self" => false)
+		pid_find = Process.pid
+		
+		proc_find = false
+		procs.each do |proc_ele|
+			if proc_ele["pid"].to_s == pid_find.to_s
+				proc_find = proc_ele
+				break
+			end
+		end
+		
+		return proc_find
+	end
+	
+	def initialize(data)
+		@data = data
+	end
+	
+	def update_data(data)
+		@data = data
+	end
+	
+	def [](key)
+		raise "No such data: #{key}" if !@data.has_key?(key)
+		return @data[key]
+	end
+	
+	def kill
+		Process.kill(9, @data["pid"].to_i)
+	end
+end