procemon 0.0.1

data/lib/procemon.rb

@@ -0,0 +1,55 @@
+#encoding: UTF-8
+module Procemon
+
+  # load up helpers
+
+  Dir.glob(\
+      File.join(\
+          File.dirname(__FILE__),\
+          __FILE__.to_s.split(File::Separator).last.split('.')[0],
+          '**',"*.{rb,ru}"\
+      )\
+  ).uniq.sort.each do |one_helper_file|
+    load one_helper_file
+  end
+
+
+  def self.init_all
+
+    # process the ARGV parameters
+    process_parameters
+
+    # project name
+    set_app_name_by_root_folder
+
+    # init temporarily directory
+    tmpdir_init
+
+    # create config singleton
+    generate_config
+
+    # load meta-s
+    meta_load
+
+    # mount libs
+    mount_libs
+
+    # mount offline modules
+    mount_modules
+
+    # garbage collect
+    ObjectSpace.garbage_collect
+
+    # documentation generate
+    generate_documentation(Application.create_documentation)
+
+    # Daemonize
+    Daemon.init
+
+  end
+
+  ### Load the requirements in to the general Module
+  #load File.expand_path(File.join(File.dirname(__FILE__),'procemon'
+
+
+end

data/lib/procemon/function/application.rb

@@ -0,0 +1,20 @@
+module Application
+  class << self
+    attr_accessor :config,
+                  :environment,
+                  :tmpdir,
+                  :daemon_stderr,
+                  :log,
+                  :pid,
+                  :name,
+                  :db_init,
+                  :db_drop,
+                  :daemon,
+                  :config_file,
+                  :create_documentation
+  end
+  self.config= Hash.new()
+  self.environment= String.new()
+end
+
+App= Application unless defined?(App)

data/lib/procemon/function/argv.rb

@@ -0,0 +1,84 @@
+module Procemon
+  class << self
+
+
+    def process_parameters
+      ARGV.each do |one_param|
+
+        case one_param.downcase
+
+          when "--debug","-deb"
+            $DEBUG= true
+
+          when "--test","-test"
+            $TEST= true
+
+          when "--database_init","-init"
+            Application.db_init= true
+
+          when "--daemon","-d"
+            Application.daemon= "start"
+
+          when "--kill","-kill"
+            Application.daemon= "stop"
+
+          when "--debuger","-bugger"
+            require "debugger"
+            debugger
+
+          when "--config","-c"
+            Application.config_file= ARGV[(ARGV.index(one_param)+1)]
+
+          when "--environment","-e"
+            Application.environment= ARGV[(ARGV.index(one_param)+1)]
+
+          when "--documentation","--generate_documentation","-doc"
+            Application.create_documentation= true
+
+          when "--db_drop","--drop_database","-dbdrop"
+            Application.db_drop= true
+
+          when "-log","--log"
+            Application.log= ARGV[(ARGV.index(one_param)+1)]
+            Application.daemon_stderr= ARGV[(ARGV.index(one_param)+1)]+"_stderr"
+
+          when "-pid","--pid"
+            Application.log= ARGV[(ARGV.index(one_param)+1)]
+
+          when "--help","-h","-help","help"
+            puts "",["This are trigger a documentation generation and than exit the application:",
+                     "--documentation",
+                     "--generate_documentation",
+                     "-doc","",
+                     "This is for set target ENV to the Application by name",
+                     "--environment","-e","",
+                     "this is for target a config file:",
+                     "--config","-c","",
+                     "This is for use debugger (development tool)",
+                     "--debug","-bug","",
+                     "This is for start application as a forked background process",
+                     "--daemon","-d","",
+                     "This is for drop database data",
+                     "--db_drop","--drop_database","-dbdrop","",
+                     "This is for send init command at start up for database",
+                     "--database_init","-init","",
+                     "This is for start in debug mode",
+                     "--debug","-deb","",
+                     "This is for set pid file location by path",
+                     "-pid","--pid","",
+                     "This is for set log file location by path",
+                     "-log","--log","",
+                     "This is for to stop daemonized application",
+                     "--kill","-kill",""
+
+            ].each{|element| element.include?('--') ? element.gsub!('--',"\t--") : element.gsub!('-',"\t -")}.join("\n"),""
+            Process.exit!
+
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/procemon/function/daemon.rb

@@ -0,0 +1,188 @@
+# use Daemon.daemonize or Process.daemonize
+class Daemon
+
+  # Checks to see if the current process is the child process and if not
+  # will update the pid file with the child pid.
+  def self.start pid, pidfile, outfile, errfile
+    unless pid.nil?
+      raise "Fork failed" if pid == -1
+      write pid, pidfile #if kill pidfile
+      exit
+    else
+      redirect outfile, errfile
+    end
+  end
+
+  # Attempts to write the pid of the forked process to the pid file.
+  def self.write pid, pidfile
+    File.create(pidfile,"w","") if File.exists?(Application.pid)
+    File.open pidfile, "a+" do |new_line|
+      new_line.write "#{pid}\n"
+    end
+  rescue ::Exception => e
+    $stderr.puts "While writing the PID to file, unexpected #{e.class}: #{e}"
+    Process.kill "HUP", pid
+  end
+
+  # Try and read the existing pid from the pid file and signal the
+  # process. Returns true for a non blocking status.
+  def self.kill(pidfile)
+    opid = File.open(File.join".",pidfile).read.strip.to_i
+    Process.kill 'HUP', opid.to_i
+    true
+  rescue Errno::ENOENT
+    $stdout.puts "#{pidfile} did not exist: Errno::ENOENT"                        if $DEBUG
+    true
+  rescue Errno::ESRCH
+    $stdout.puts "The process #{opid} did not exist: Errno::ESRCH"                if $DEBUG
+    true
+  rescue Errno::EPERM
+    $stderr.puts "Lack of privileges to manage the process #{opid}: Errno::EPERM" if $DEBUG
+    false
+  rescue ::Exception => e
+    $stderr.puts "While signaling the PID, unexpected #{e.class}: #{e}"           if $DEBUG
+    false
+  end
+
+  # Send stdout and stderr to log files for the child process
+  def self.redirect outfile, errfile
+    $stdin.reopen File.join('','dev','null')
+    out = File.new outfile, "a"
+    err = File.new errfile, "a"
+    $stdout.reopen out
+    $stderr.reopen err
+    $stdout.sync = $stderr.sync = true
+  end
+
+  def self.daemonize
+
+    pid_path= nil
+    log_path= nil
+    daemon_stderr= nil
+
+    begin
+      File.create Application.pid,'a+'
+      File.create Application.log,'a+'
+      File.create Application.daemon_stderr,'a+'
+
+      pid_path= Application.pid
+      log_path= Application.log
+      daemon_stderr= Application.daemon_stderr
+    rescue Exception
+      File.create File.join(Dir.pwd, "pid", "pidfile" ),'a+'
+      File.create File.join(Dir.pwd, "log", "logfile" ),'a+'
+      File.create File.join(Dir.pwd, "log", "daemon_stderr" ),'a+'
+
+      pid_path= File.join(Dir.pwd, "pid", "pidfile" )
+      log_path= File.join(Dir.pwd, "log", "logfile" )
+      daemon_stderr= File.join(Dir.pwd, "log", "daemon_stderr" )
+    end
+
+    Daemon.start(fork,pid_path,log_path,daemon_stderr)
+
+  end
+
+  def self.kill_with_pid
+    begin
+      if File.exists?(Application.pid)
+        puts "PidFile found, processing..."  if $DEBUG
+        File.open(Application.pid).each_line do |row|
+          begin
+            Process.kill 'TERM', row.chomp.to_i
+            puts "terminated process at: #{row.chomp}" if $DEBUG
+          rescue Exception => ex
+            puts "At process: #{row.chomp}, #{ex}"     if $DEBUG
+          end
+        end
+      else
+        system "ps -ef | grep #{$0}"
+        #system "netstat --listen"
+        #puts "\nLepton is around 10300-10399"
+      end
+    rescue Exception => ex
+      puts "Exception has occured: #{ex}"
+    end
+  end
+
+  def self.terminate
+    Daemon.kill Application.pid
+    Daemon.kill_with_pid
+  end
+
+  def self.kill_by_name(*args)
+
+    target_name= nil
+    debug_mod  = false
+
+    args.each do |one_element|
+      if one_element.class == String
+        target_name = one_element
+      elsif one_element.class == TrueClass || one_element.class == FalseClass
+        debug_mod = one_element
+      end
+    end
+
+    # name switch
+    begin
+      target_name ||= $0
+      $0 = "ruby_tmp_process"
+    end
+
+    start_time= Time.now
+    while `ps aux | grep #{target_name}`.split(' ')[1] != ""  ||(Time.now - start_time) < 6
+
+      begin
+
+        Process.kill "TERM",`ps aux | grep #{target_name}`.split(' ')[1].to_i
+
+      rescue Errno::ESRCH
+        $stdout.puts "The process #{target_name} did not exist: Errno::ESRCH"                if debug_mod
+        break
+      rescue Errno::EPERM
+        $stderr.puts "Lack of privileges to manage the process #{target_name}: Errno::EPERM" if debug_mod
+        break
+      rescue ::Exception => e
+        $stderr.puts "While signaling the PID, unexpected #{e.class}: #{e}"           if debug_mod
+        break
+      end
+    end
+
+
+    # name switch back
+    begin
+      $0 = target_name
+    end
+
+    return nil
+  end
+
+  def self.stop
+
+    # kill methods
+    begin
+      self.kill_by_name true
+      self.terminate
+    end
+
+    pid_path= nil
+    begin
+      pid_path= Application.pid
+    rescue Exception
+      pid_path= File.join(Dir.pwd, "pid", "pidfile" )
+    end
+
+    File.open(pid_path, "w").write("")
+    Process.exit!
+
+  end
+
+  def self.init
+    case Application.daemon.to_s.downcase
+      when "true","start"
+        self.daemonize
+      when "stop"
+        self.stop
+    end
+  end
+
+end

data/lib/procemon/function/documentation.rb

@@ -0,0 +1,10 @@
+class String
+  def find_doc_part(oth_str)
+    self.each_line do |target_line|
+      puts target_line[0..(oth_str.length-1)]
+      if target_line[0..(oth_str.length-1)] == oth_str
+        return target_line[(oth_str.length)..(target_line.length)]
+      end
+    end
+  end
+end

data/lib/procemon/function/eval.rb

@@ -0,0 +1,76 @@
+module Kernel
+
+  # safe_eval(string [, binding [, filename [,lineno]]] *allowed_class/module_names )  -> obj
+  #
+  # Evaluates the Ruby expression(s) in <em>string</em>. If
+  # <em>binding</em> is given, which must be a <code>Binding</code>
+  # object, the evaluation is performed in its context. If the
+  # optional <em>filename</em> and <em>lineno</em> parameters are
+  # present, they will be used when reporting syntax errors.
+  #
+  #    def get_binding(str)
+  #      return binding
+  #    end
+  #    str = "hello"
+  #    safe_eval "str + ' Fred'" ,Kernel                      #=> "hello Fred"
+  #    safe_eval "str + ' Fred'", get_binding("bye") ,Kernel  #=> "bye Fred"
+  def safe_eval(*args)
+
+    # defaults
+    begin
+      allowed=  Array.new
+      eval_exception= String.new
+      tmp_array= nil
+    end
+
+    # separate allowed names
+    begin
+      tmp_array= Array.new
+      args.each do |argument|
+        case argument.class.to_s.downcase
+
+          when "class","module"
+            begin
+              allowed.push argument
+            end
+
+          else
+            begin
+              tmp_array.push argument
+            end
+
+        end
+      end
+      args= tmp_array
+    end
+
+    # build exception list to eval
+    begin
+      allowed.each do |one_name|
+        eval_exception += "|"+one_name.to_s
+      end
+    end
+
+    # trim un wanted elements from string
+    begin
+      args.each do |argument|
+        case argument.class.to_s.downcase
+
+          when "string"
+            begin
+              #TODO new regex!  # /(\b|\.|\{|\>)[A-Z]\w*/
+              #args[args.index(argument)]= argument.gsub( /(\b|\.|\{|\>)[A-Z]\w*/ ,'')
+            end
+
+        end
+      end
+    end
+
+    # do save eval
+    begin
+      eval(*args)
+    end
+
+  end if $DEBUG == true
+
+end

data/lib/procemon/function/meta/inject_methods.rb

@@ -0,0 +1,74 @@
+class Class
+
+  # this will inject a code block to a target instance method
+  # by default the before or after sym is not required
+  # default => before
+  #
+  #  Test.inject_singleton_method :hello do |*args|
+  #    puts "singleton extra, so #{args[0]}"
+  #  end
+  #
+  def inject_singleton_method(method,options=:before,&block)
+
+    original_method= self.method(method).clone
+    #Singleton.methods[self.object_id]= self.method(method)
+    self.singleton_class.__send__ :undef_method, method
+    self.class_eval do
+      define_singleton_method method do |*arguments|
+        case true
+
+          when options == :before
+            begin
+              block.call *arguments
+              original_method.call *arguments
+            end
+
+          when options == :after
+            begin
+              original_method.call *arguments
+              block.call *arguments
+            end
+
+        end
+      end
+    end
+
+  end
+
+  # this will inject a code block to a target singleton method
+  # by default the before or after sym is not required
+  # default => before
+  #
+  #  Test.inject_instance_method :hello, :before do |*args|
+  #    puts "singleton on a instance method and "+args[0]
+  #  end
+  #
+  def inject_instance_method(method,options=:before,&block)
+    self.class_eval do
+      alias_method :"old_#{method.to_s}", method
+    end
+    extended_process = Proc.new do |*args|
+
+      case true
+
+        when options == :before
+          begin
+            block.call *args
+            self.__send__ :"old_#{method.to_s}", *args
+          end
+
+        when options == :after
+          begin
+            self.__send__ :"old_#{method.to_s}", *args
+            block.call *args
+          end
+
+      end
+
+    end
+    self.class_eval do
+      define_method method, extended_process#Proc call
+    end
+  end
+
+end