procemon 1.2.1 → 2.0.0

data/examples/how_to_inject_with_extra_process_a_method.rb

@@ -1,38 +0,0 @@
-require_relative "../lib/procemon.rb"
-
-class TestT
-
-  def self.test
-    puts self
-  end
-
-  def test string
-    puts self,string
-  end
-
-end
-
-TestT.inject_instance_method :test do |str|
-
-  puts "hello world! instance "+str
-
-end
-
-TestT.inject_singleton_method :test, add: "after" do
-  puts "hello world! singleton"
-end
-
-puts "---\nafter,singleton case:"
-TestT.test
-
-puts "---\nbefore,instance case:"
-TestT.new.test "boogie man"
-
-
-#after,singleton case:
-#TestT
-#hello world! singleton
-#
-#before,instance case:
-#hello world! instance
-##<TestT:0x00000000d4a008>

data/examples/require_files.rb

@@ -1,3 +0,0 @@
-require_relative "../lib/procemon.rb"
-
-require_relative_directory "foldername_path_from_this_file"

data/files.rb

@@ -1,24 +0,0 @@
-### Get Files from dir
-begin
-
-  files_to_be_loaded = %w[version.rb]
-
-  SpecFiles= Array.new
-
-  Dir[File.expand_path(File.join(File.dirname(__FILE__),"**","*"))].sort.uniq.each do |one_file_name|
-    one_file_name = File.expand_path one_file_name
-    file_name = one_file_name[(File.expand_path(File.dirname(__FILE__)).to_s.length+1)..(one_file_name.length-1)]
-
-    if !one_file_name.include?("pkg")
-      if !File.directory? file_name
-        SpecFiles.push file_name
-        STDOUT.puts file_name if $DEBUG
-        if files_to_be_loaded.include? one_file_name.split(File::SEPARATOR).last
-          load one_file_name
-        end
-      end
-    end
-
-  end
-
-end

data/lib/procemon/extra/sender.rb

@@ -1,30 +0,0 @@
-module Kernel
-
-  def sender
-    sender_properties= Hash.new
-    # File system
-    begin
-      # folder create from caller
-      begin
-        folder= caller[0].split(".{rb,ru}:").first.split(File::SEPARATOR)
-        sender_properties[:file]= folder[(folder.count-1)].split(':')[0]
-        folder= folder[0..(folder.count-2)]
-      end
-      # after formatting
-      begin
-
-        if !File.directory?(folder.join(File::SEPARATOR))
-          folder.pop
-        end
-        folder= File.join(folder.join(File::SEPARATOR))
-        if folder != File.expand_path(folder)
-          folder= File.expand_path(folder)
-        end
-
-      end
-      sender_properties[:folder]= folder
-    end
-    return sender_properties
-  end
-
-end

data/lib/procemon/extra/str2duck.rb

@@ -1,7 +0,0 @@
-begin
-
-  require File.join 'active_support','time'
-  require File.join 'mpatch','active_support','str2duck'
-
-rescue LoadError
-end

data/lib/procemon/function/application.rb

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

data/lib/procemon/function/argv.rb

@@ -1,78 +0,0 @@
-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 "--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.doc= 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 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

@@ -1,188 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-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/file.rb

@@ -1,67 +0,0 @@
-class File
-
-  # create a file, if not exsist create file, and dir if needed
-  def self.create(route_name ,filemod="w",string_data= ::String.new )
-
-    #file_name generate
-    if !route_name.to_s.split(File::SEPARATOR).last.nil? || route_name.to_s.split(File::SEPARATOR).last != ''
-      file_name = route_name.to_s.split(File::SEPARATOR).last
-    else
-      file_name = nil?
-    end
-
-    #path_way
-    begin
-      raise ::ArgumentError, "missing route_name: #{route_name}"   if route_name.nil?
-      path = File.expand_path(route_name).to_s.split(File::SEPARATOR)
-      path = path - [File.expand_path(route_name).to_s.split(File::SEPARATOR).last]
-      path.shift
-    end
-
-    #job
-    begin
-      if !::Dir.exists?(File::SEPARATOR+path.join(File::SEPARATOR))
-
-        at_now = File::SEPARATOR
-        path.each do |dir_to_be_checked|
-
-          at_now += "#{dir_to_be_checked+File::SEPARATOR}"
-          ::Dir.mkdir(at_now) if !::Dir.exists?(at_now)
-
-        end
-      end
-    end
-
-    # write data
-    begin
-      full_path = "#{File::SEPARATOR+path.join(File::SEPARATOR)+File::SEPARATOR}#{file_name}"
-      if File.exist? full_path
-        File.open(full_path,filemod).write string_data
-      else
-        File.new(full_path,filemod).write string_data
-      end
-    end
-
-  end
-
-  # start read the file object on each line
-  # optionable an integer value to start read line at
-  # compatible with mac (i am linux user, so not tested)
-  def each_line_from(start_at=1,&block)
-    unless [::Integer,Fixnum,Bignum].include?(start_at.class)
-      raise ::ArgumentError, "invalid line index"
-    end
-    begin
-      line_num= 1
-      text= self.read
-      text.gsub!(/\r\n?/, "\n")
-      text.each_line do |*line|
-        if line_num >= start_at
-          block.call #*line
-        end
-        line_num += 1
-      end
-    end
-  end
-
-end