knjrbfw 0.0.3

data/lib/knj/sshrobot/sshrobot.rb

@@ -0,0 +1,93 @@
+class Knj::SSHRobot
+	def initialize(args)
+		@forwards = []
+		@args = Knj::ArrayExt.hash_sym(args)
+		@args[:port] = 22 if !@args.has_key?(:port)
+	end
+	
+	def session
+		@session = self.session_spawn if !@session
+		return @session
+	end
+	
+	def session_spawn
+		return Net::SSH.start(@args[:host], @args[:user], :password => @args[:passwd], :port => @args[:port].to_i)
+	end
+	
+	def shell
+		return self.session.shell.sync
+	end
+	
+	def sftp
+		@sftp = Net::SFTP.start(@args[:host], @args[:user], @args[:passwd], :port => @args[:port].to_i)
+	end
+	
+	def exec(command)
+		return self.session.exec!(command)
+	end
+	
+	def fileExists(filepath)
+		result = self.exec("ls " + Strings.UnixSafe(filepath)).strip
+		
+		if result == filepath
+			return true
+		else
+			return false
+		end
+	end
+	
+	def forward(args)
+		Knj::ArrayExt.hash_sym(args)
+		args[:type] = "local" if !args[:type]
+		args[:session] = self.session_spawn if !args[:session]
+		args[:host_local] = "0.0.0.0" if !args[:host_local]
+		
+		return SSHRobot::Forward.new(args)
+	end
+	
+	alias getShell shell
+	alias getSFTP sftp
+	alias shellCMD exec
+end
+
+class Knj::SSHRobot::Forward
+	attr_reader :open
+	
+	def initialize(args)
+		@open = true
+		@args = args
+		@thread = Knj::Thread.new do
+			begin
+				#args[:session].logger.sev_threshold = Logger::Severity::DEBUG
+				if args[:type] == "local"
+					@args[:session].forward.local(@args[:host_local], @args[:port_local].to_i, @args[:host], @args[:port_remote].to_i)
+				elsif args[:type] == "remote"
+					@args[:session].forward.remote_to(@args[:port_local], @args[:host], @args[:port_remote], @args[:host_local])
+				else
+					raise "No valid type given."
+				end
+				
+				@args[:session].loop do
+					true
+				end
+			rescue Exception => e
+				puts e.inspect
+				puts e.backtrace
+				
+				@open = false
+			end
+		end
+	end
+	
+	def close
+		if !@args
+			return nil
+		end
+		
+		@args[:session].close
+		@open = false
+		@thread.exit
+		@args = nil
+		@thread = nil
+	end
+end

data/lib/knj/strings.rb

@@ -0,0 +1,65 @@
+module Knj::Strings
+	def self.UnixSafe(tha_string)
+		return tha_string.to_s.gsub(" ", "\\ ").gsub("&", "\&").gsub("(", "\\(").gsub(")", "\\)").gsub('"', '\"').gsub("\n", "\"\n\"")
+	end
+	
+	def self.unixsafe(string)
+		return Knj::Strings.UnixSafe(string)
+	end
+	
+	def self.searchstring(string)
+		words = []
+		string = string.to_s
+		
+		matches = string.scan /(\"(.+?)\")/
+		matches.each do |matcharr|
+			word = matcharr[1]
+			
+			if word and word.length > 0
+				words << matcharr[1]
+				string = string.gsub(matcharr[0], "")
+			end
+		end
+		
+		string.split(/\s/).each do |word|
+			words << word if word and word.length > 0
+		end
+		
+		return words
+	end
+	
+	def self.is_email?(str)
+		return true if str.to_s.match(/^\S+@\S+\.\S+$/)
+		return false
+	end
+	
+	def self.is_phonenumber?(str)
+		return true if str.to_s.match(/^\+\d{2}\d+$/)
+		return false
+	end
+	
+	def self.js_safe(str)
+		return str.gsub("\r", "").gsub("\n", "\\n").gsub('"', '\"');
+	end
+	
+	def self.yn_str(value, str_yes, str_no)
+		value = value.to_i if Knj::Php.is_numeric(value)
+		
+		if value.is_a?(Integer)
+			if value == 0
+				return str_no
+			else
+				return str_yes
+			end
+		end
+		
+		return str_no if !value
+		return str_yes
+	end
+	
+	def self.shorten(str, maxlength)
+		str = str.to_s
+		str = str.slice(0..(maxlength - 1)).strip + "..." if str.length > maxlength
+		return str
+	end
+end

data/lib/knj/sysuser.rb

@@ -0,0 +1,27 @@
+class Knj::Sysuser
+	def initialize(data)
+		@data = data
+	end
+	
+	def self.list(paras = {})
+		cont = File.read("/etc/passwd")
+		
+		list = []
+		cont.split("\n").each do |line|
+			linearr = line.split(":")
+			
+			list << Knj::Sysuser.new(
+				"nick" => linearr[0],
+				"home" => linearr[5],
+				"shell" => linearr[6]
+			)
+		end
+		
+		return list
+	end
+	
+	def [](key)
+		raise "No such key: " + key if !@data.has_key?(key)
+		return @data[key]
+	end
+end

data/lib/knj/tests/compiler/compiler_test.rb

@@ -0,0 +1,13 @@
+require "knj/knj"
+require "knj/compiler"
+
+compiler = Knj::Compiler.new
+
+time_start = Time.new.to_f
+
+#0.upto(10000) do
+	compiler.eval_file("compiler_test_file.rb")
+#end
+
+time_spent = Time.new.to_f - time_start
+print "#{time_spent}\n"

data/lib/knj/tests/compiler/compiler_test_file.rb

@@ -0,0 +1,62 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+#
+#  contributed by Karl von Laudermann
+#  modified by Jeremy Echols
+#  modified by Detlef Reichl
+#  modified by Joseph LaFata
+#  modified by Peter Zotov
+
+size = ARGV.shift.to_i
+
+puts "P4\n#{size} #{size}"
+
+byte_acc = 0
+bit_num = 0
+
+y = 0
+while y < size
+  ci = (2.0*y/size)-1.0
+
+  x = 0
+  while x < size
+    zrzr = zr = 0.0
+    zizi = zi = 0.0
+    cr = (2.0*x/size)-1.5
+    escape = 0b1
+
+    z = 0
+    while z < 50
+      tr = zrzr - zizi + cr
+      ti = 2.0*zr*zi + ci
+      zr = tr
+      zi = ti
+      # preserve recalculation
+      zrzr = zr*zr
+      zizi = zi*zi
+      if zrzr+zizi > 4.0
+        escape = 0b0
+        break
+      end
+      z += 1
+    end
+
+    byte_acc = (byte_acc << 1) | escape
+    bit_num += 1
+
+    # Code is very similar for these cases, but using separate blocks
+    # ensures we skip the shifting when it's unnecessary, which is most cases.
+    if (bit_num == 8)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    elsif (x == size - 1)
+      byte_acc <<= (8 - bit_num)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    end
+    x += 1
+  end
+  y += 1
+end

data/lib/knj/tests/test_degulesider.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "knj/autoload"
+include Knj
+
+dgs = Degulesider.new
+results = dgs.search(
+	:where => "Engvej 3, 4970 Rødby"
+)
+
+Php.print_r(results)

data/lib/knj/tests/test_mount.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__))
+require "../autoload"
+
+print "Listing all mounts.\n"
+mounts = Knj::Mount.list
+mounts.each do |mount|
+	Knj::Php.print_r(mount.data)
+	print "Access: #{mount.access?}\n\n"
+end
+
+mounts = Knj::Mount.list("from_search" => "test_dir")
+mounts.each do |mount|
+	print "Unmounting test_dir.\n"
+	mount.umount
+end
+
+print "Mount binding test_dir to test_dir_to.\n"
+Knj::Mount.mount(
+	"from" => "test_dir",
+	"to" => "test_dir_to",
+	"bind" => true
+)
+
+mounts = Knj::Mount.list("from_search" => "test_dir")
+mounts.each do |mount|
+	print "Unmounting test_dir.\n"
+	mount.umount
+end

data/lib/knj/tests/test_retry.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__))
+require "../autoload"
+
+count = 0
+result = Knj::Retry.try(
+	:exit => false,
+	:interrupt => true,
+	:errors => [Knj::Errors::NotFound, RuntimeError],
+	:timeout => 1,
+	:tries => 3,
+	:return_error => true
+) do
+	count += 1
+	print "Count: #{count.to_s}\n"
+	
+	if count <= 2
+		exit
+	end
+	
+	if count <= 3
+		
+		#raise "Test"
+	end
+end
+
+#print "Error 1 was a #{result[0][:error].class.to_s} with the message: #{result[0][:error].message.to_s}\n"
+
+Knj::Php.print_r(result)

data/lib/knj/thread.rb

@@ -0,0 +1,32 @@
+#This class behaves like a normal thread - but it shows error-messages and tracebacks. Normal threads dont do that.
+class Knj::Thread < Thread
+	attr_accessor :data
+	
+	def initialize(*args, &block)
+		@data = {}
+		raise "No block was given." if !block_given?
+		
+		abort_on_exception = true
+		super(*args) do
+			begin
+				block.call(*args)
+			rescue SystemExit
+				exit
+			rescue Exception => e
+				print "Error: "
+				puts e.inspect
+				print "\n"
+				puts e.backtrace
+				print "\n\n"
+			end
+		end
+	end
+	
+	def [](key)
+		return @data[key]
+	end
+	
+	def []=(key, value)
+		return @data[key] = value
+	end
+end

data/lib/knj/thread2.rb

@@ -0,0 +1,47 @@
+class Knj::Thread2
+	def initialize(args = {}, &block)
+		@args = args
+		@block = block if block_given?
+		@callbacks = {}
+	end
+	
+	def connect(signal, &block)
+		@callbacks[signal] = [] if !@callbacks.has_key?(signal)
+		@callbacks[signal] << block
+	end
+	
+	def call(signal, *args)
+		return false if !@callbacks.has_key?(signal)
+		@callbacks[signal].each do |block|
+			block.call(*args)
+		end
+		
+		return {:count => count}
+	end
+	
+	def run
+		Thread.new do
+			abort_on_exception = true
+			call(:on_run)
+			
+			begin
+				@block.call
+			rescue SystemExit
+				call(:on_exit)
+				exit
+			rescue Exception => e
+				call(:on_error, e)
+				
+				if !@args.has_key?(:print_error) or @args[:print_error]
+					print "Error: "
+					puts e.inspect
+					print "\n"
+					puts e.backtrace
+					print "\n\n"
+				end
+			end
+			
+			call(:on_done)
+		end
+	end
+end

data/lib/knj/threadhandler.rb

@@ -0,0 +1,130 @@
+class Knj::Threadhandler
+	attr_reader :inactive_blocks, :args, :activate_blocks, :mutex
+	
+	def initialize(args = {})
+		@args = args
+		@objects = []
+		@args[:timeout] = 5 if !@args[:timeout]
+		@inactive_blocks = []
+		@activate_blocks = []
+		@mutex = Mutex.new
+		
+		@thread_timeout = Knj::Thread.new do
+			loop do
+				sleep @args[:timeout]
+				break if !@mutex
+				check_inactive
+			end
+		end
+	end
+	
+	def on_spawn_new(&block)
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+		@spawn_new_block = block
+	end
+	
+	def on_inactive(&block)
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+		@inactive_blocks << block
+	end
+	
+	def on_activate(&block)
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+		@activate_blocks << block
+	end
+	
+	def destroy
+    return false if !@mutex
+    
+    @thread_timeout.kill if @thread_timeout and @thread_timeout.alive?
+    @thread_timeout = nil
+    
+    @mutex.synchronize do
+      @objects.each do |data|
+        @inactive_blocks.each do |block|
+          data[:inactive] = true
+          block.call(:obj => data[:object])
+        end
+      end
+    end
+    
+    @args = nil
+    @objects = nil
+    @inactive_blocks = nil
+    @activate_blocks = nil
+    @mutex = nil
+	end
+	
+	def check_inactive
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+		@mutex.synchronize do
+			cur_time = Time.new.to_i - @args[:timeout]
+			@objects.each do |data|
+				if data[:free] and !data[:inactive] and data[:free] < cur_time
+					@inactive_blocks.each do |block|
+						data[:inactive] = true
+						block.call(:obj => data[:object])
+					end
+				end
+			end
+		end
+	end
+	
+	def get_and_lock
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+		newobj = nil
+		
+		@mutex.synchronize do
+			retdata = false
+			@objects.each do |data|
+				if data[:free]
+					retdata = data
+					break
+				end
+			end
+			
+			if retdata
+				#Test if object is still free - if not, try again - knj.
+				return get_and_lock if !retdata[:free]
+				retdata[:free] = false
+				
+				if retdata[:inactive]
+					@activate_blocks.each do |block|
+						block.call(:obj => retdata[:object])
+					end
+					
+					retdata.delete(:inactive)
+				end
+				
+				return retdata[:object]
+			end
+			
+			newobj = @spawn_new_block.call
+			@objects << {
+				:free => false,
+				:object => newobj
+			}
+			STDOUT.print "Spawned db and locked new.\n" if @args[:debug]
+		end
+		
+		return newobj
+	end
+	
+	def free(obj)
+    raise "Destroyed Knj::Threadhandler." if !@mutex
+    
+		@mutex.synchronize do
+			freedata = false
+			@objects.each do |data|
+				if data[:object] == obj
+					freedata = data
+					break
+				end
+			end
+			
+			raise "Could not find that object in list." if !freedata
+			STDOUT.print "Freed one.\n" if @args[:debug]
+			freedata[:free] = Time.new.to_i
+		end
+	end
+end