daemon-ogre 1.5.0 → 2.0.0

data/example/sample_daemon_app.rb

@@ -1,19 +0,0 @@
-require_relative File.join '..','lib','daemon-ogre.rb'
-
-# start as
-#   ruby sample_daemon_app.rb start daemon
-#
-# to check it's running
-#   ps aux | grep MySuperAppName
-
-DaemonOgre.start :name      => "MySuperAppName",
-                 :log_path  => File.join('.','var','log','log_file_name'),
-                 :pid_path  => File.join('.','var','pid','pid_file_name'),
-                 :terminate => true
-
-10.times do
-
-  puts Time.now
-  sleep 1
-
-end

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/daemon-ogre/app.rb

@@ -1,40 +0,0 @@
-#DaemonOgreBody
-begin
-  module DaemonOgre
-
-    #config
-    begin
-      class App
-        class << self
-          attr_accessor :log_path,
-                        :pid_path,
-                        :daemon_stderr,
-                        :exceptions,
-                        :exlogger,
-                        :app_name,
-                        :port,
-                        :terminate
-        end
-      end
-    end
-
-    #default
-    begin
-      App.log_path   = "./var/log/logfile.log"
-      App.pid_path   = "./var/pid/pidfile.pid"
-      App.terminate  = false
-      App.port       = 80
-      App.app_name   = $0
-
-      begin
-        ['daemon_stderr','exceptions','exlogger'].each do |one_log|
-
-          App.__send__(one_log+"=",clone_mpath(App.log_path,one_log+".log"))
-
-        end
-      end
-
-    end
-
-  end
-end

data/lib/daemon-ogre/mpatch.rb

@@ -1,93 +0,0 @@
-#monkey patch
-begin
-  def process_running?(input)
-    DaemonOgre.process_running?(input)
-  end
-  def require_directory(directory,*args)
-    DaemonOgre.load_directory(directory,{:monkey_patch => 1},*args)
-  end
-  def require_ymls(directory)
-    DaemonOgre.load_ymls(
-        directory,
-        {:monkey_patch => 1}
-    )
-  end
-  def get_port(port,max_port=65535 ,host="0.0.0.0")
-    DaemonOgre.get_port(port,max_port,host)
-  end
-  def exlogger(error_msg,*args)
-    arg=Hash[*args]
-    arg[:prefix] = String.new                if arg[:prefix].nil?
-    arg[:path]   = DaemonOgre::App.exlogger  if arg[:path].nil?
-    DaemonOgre.create_on_filesystem arg[:path],
-                         'a+'
-    DaemonOgre.error_logger(error_msg,arg[:prefix],arg[:path])
-  end
-
-
-  class Exception
-    def logger
-      DaemonOgre.create_on_filesystem DaemonOgre::App.exceptions,
-                                      'a+'
-      DaemonOgre.error_logger(self.backtrace,self,DaemonOgre::App.exceptions)
-    end
-  end
-  class File
-    def self.create!(file,optionable_data=nil,optionable_file_mod="w")
-      DaemonOgre.create_on_filesystem file,
-                                      optionable_file_mod,
-                                      optionable_data
-    end
-  end
-  class Class
-    def class_methods
-      self.methods - Object.methods
-    end
-    def self.class_methods
-      self.methods - Object.methods
-    end
-  end
-  class Rnd
-    class << self
-      def string(length,amount=1)
-        mrg = String.new
-        first_string = true
-        amount.times do
-          a_string = Random.rand(length)
-          a_string == 0 ? a_string += 1 : a_string
-          mrg_prt  = (0...a_string).map{ ('a'..'z').to_a[rand(26)] }.join
-          first_string ? mrg += mrg_prt : mrg+= " #{mrg_prt}"
-          first_string = false
-        end
-        return mrg
-      end
-      def integer(length)
-        Random.rand(length)
-      end
-      def boolean
-        rand(2) == 1
-      end
-      def date from = Time.at(1114924812), to = Time.now
-        rand(from..to)
-      end
-    end
-  end
-  class Array
-    def index_of(target_element)
-      array = self
-      hash = Hash[array.map.with_index.to_a]
-      return hash[target_element]
-    end
-  end
-  class Hash
-    #pass single or array of keys, which will be removed, returning the remaining hash
-    def remove!(*keys)
-      keys.each{|key| self.delete(key) }
-      self
-    end
-    #non-destructive version
-    def remove(*keys)
-      self.dup.remove!(*keys)
-    end
-  end
-end

data/lib/daemon-ogre/server.rb

@@ -1,199 +0,0 @@
-#DaemonOgreBody
-begin
-  module DaemonOgre
-
-    #server_model
-    begin
-      class Server
-        @@startup = false
-        class << self
-
-          def daemon
-            puts "#{$0} daemon is watching you..."
-            DaemonOgre.create_on_filesystem DaemonOgre::App.pid_path,
-                                            'a+'
-            DaemonOgre.create_on_filesystem DaemonOgre::App.log_path,
-                                            'a+'
-            DaemonOgre.create_on_filesystem DaemonOgre::App.daemon_stderr,
-                                            'a+'
-
-
-            DaemonOgre::Daemon.start fork,
-                         DaemonOgre::App.pid_path,
-                         DaemonOgre::App.log_path,
-                         DaemonOgre::App.daemon_stderr
-          end
-
-          def debug
-            $DEBUG = true
-          end
-
-          def help
-            puts "\nyou can use one of these commands: "+\
-            "\nstart	daemon -d	stop	restart	log	-l	pid	-p	port	-tcp	status	reset	help"+\
-            "\n==============================================================================DESC======>>"
-            puts "start\t\t\t\t=> this will start the #{$0}"+\
-             "\ndaemon\t\t\t\t=> this will make is daemon process"+\
-             "\nstop\t\t\t\t=> this will kill the last process with pidfile"+\
-             "\nrestart\t\tor reset\t=> hard restart"+\
-             "\nlog\t\tor -l\t\t=> logfile place"+\
-             "\npid\t\tor -p\t\t=> pid file place (if you want set the filename as well, put .pid or .txt in the end)"+\
-             "\nport\t\tor -tcp\t\t=> user definiated port"+\
-             "\nstatus\t\t\t\t=> last process alive?"+\
-             "\ndebug\t\tor -d\t\t=> show debug log (you can make your own by using 'puts 'xy' if $DEBUG' "+\
-             "\nhelp\t\t\t\tgive you this msg :)\n"
-            DaemonOgre::App.terminate=true
-          end
-
-          def start
-            if File.exist?(File.expand_path(App.pid_path))
-              text = File.open(File.expand_path(App.pid_path)).read
-              terminate_on_command = Array.new
-              text.each_line do |line|
-                terminate_on_command.push DaemonOgre.process_running?(line)
-              end
-            end
-
-            if !terminate_on_command.nil?
-              if !terminate_on_command.include?(true)
-                @@startup = true
-              else
-                puts "sorry but process is already running in this specification"
-                Process.exit
-              end
-            else
-              @@startup = true
-            end
-          end
-
-          def stop
-            puts "#{$0} is going to be FacePalmed..."
-            Daemon.kill DaemonOgre::App.pid_path
-            kill_with_pid
-            File.open(DaemonOgre::App.pid_path, "w").write("")
-            DaemonOgre::App.terminate=true
-
-          end
-
-          def restart
-
-            Daemon.kill DaemonOgre::App.pid_path
-            kill_with_pid
-            File.open(DaemonOgre::App.pid_path, "w").write("")
-            start
-
-          end
-
-          def kill_with_pid
-            begin
-              if File.exists?(DaemonOgre::App.pid_path)
-                puts "PidFile found, processing..."  if $DEBUG
-                File.open(DaemonOgre::App.pid_path).each_line do |row|
-                  begin
-                    Process.kill 'TERM', row.to_i
-                    puts "terminated process at: #{row}" if $DEBUG
-                  rescue Exception => ex
-                    puts "At process: #{row}, #{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 continue?
-            Process.exit if !@@startup
-          end
-
-          def set_log(param)
-            ARGV.each do |one_parameter|
-              if one_parameter == param
-                DaemonOgre::App.log_path= ARGV[ARGV.index(one_parameter)+1]
-              end
-            end
-          end
-
-          def set_pid(param)
-            ARGV.each do |one_parameter|
-              if one_parameter == param
-                if ARGV[ARGV.index(one_parameter)+1].to_s.include?(".pid") ||\
-                   ARGV[ARGV.index(one_parameter)+1].to_s.include?(".txt")
-                  DaemonOgre::App.pid_path= ARGV[ARGV.index(one_parameter)+1]
-                else
-                  DaemonOgre::App.pid_path= ARGV[ARGV.index(one_parameter)+1].to_s+"lepton.pid"
-                end
-              end
-            end
-          end
-
-          def set_port(param)
-            ARGV.each do |one_parameter|
-              if one_parameter == param
-                DaemonOgre::App.port= ARGV[ARGV.index(one_parameter)+1]
-              end
-            end
-          end
-
-          def pid
-            begin
-              if !DaemonOgre::App.pid_path.nil?
-                DaemonOgre::App.pid_path+="lepton.pid"  if !DaemonOgre::App.pid_path.include?(".pid")
-                pre_path = File.dirname "#{File.dirname(__FILE__)}/#{DaemonOgre::App.pid_path}"
-                pre_path_array = pre_path.split('/') - [ pre_path[0].to_s ]
-                if !Dir.exists?(pre_path)
-                  at_now = String.new
-                  pre_path_array.each do |one_dir_to_be_made|
-                    #at_now show the place where we are now
-                    at_now == ""  ?  at_now += one_dir_to_be_made  :  at_now += "/"+one_dir_to_be_made
-                    if !Dir.exists?("#{File.dirname(__FILE__)}/#{at_now}")
-                      Dir.mkdir("#{File.dirname(__FILE__)}/#{at_now}")
-                    end
-                  end
-                end
-                File.new("#{File.dirname(__FILE__)}/#{DaemonOgre::App.pid_path}", "a+").write Process.pid.to_s+"\n"
-              end
-            rescue Exception => ex
-              ex.logger
-            end
-          end
-
-          def pid_check
-            if File.exist?(File.expand_path(App.pid_path))
-              puts "checking pidfile:"
-              text = File.open(File.expand_path(App.pid_path)).read
-              text.each_line do |line|
-                puts "#{line.chomp}:\t#{DaemonOgre.process_running?(line)}"
-              end
-            else
-              puts "missing pid file (with default path) "+\
-              "\nif you specificated one manualy pls type"+\
-              " the path first in with '-p xy/xzt.pid'"
-            end
-            DaemonOgre::App.terminate=true
-          end
-
-          def clear
-
-            logs = ['loh_path','daemon_stderr','exceptions','exlogger']
-
-            logs.each do |logname|
-              begin
-               File.delete DaemonOgre::App.__send__(logname)
-              rescue Exception => ex
-                puts ex if $DEBUG
-              end
-            end
-
-          end
-
-        end
-      end
-    end
-
-  end
-end

data/lib/daemon-ogre/startup.rb

@@ -1,85 +0,0 @@
-module DaemonOgre
-  def self.start(*args)
-    arg = Hash[*args]
-
-    ##defaults:
-    #arg[:log_path]
-    #arg[:pid_path]
-
-    #arg[:name]
-    #arg[:port]
-
-    #arg[:terminate]
-    #arg[:clear]
-
-    begin
-
-      begin
-
-        App.pid_path  = arg[:pid_path]  if !arg[:pid_path].nil?
-        App.log_path  = arg[:log_path]  if !arg[:log_path].nil?
-
-        $0 = arg[:name]      if !arg[:name].nil?
-        App.port      = arg[:port]      if !arg[:port].nil?
-
-        App.terminate = arg[:terminate] if !arg[:terminate].nil?
-
-      end
-
-
-      if ARGV.nil?
-        puts "No server task has been given!"
-        DaemonOgre::Server.help
-      end
-      serv_load = Array.new
-      ARGV.each do |one_argv_parameter|
-        case one_argv_parameter.downcase
-          when "start"    then serv_load.push  "start"
-          when "daemon"   then serv_load.push  "daemon"
-          when "-d"       then DaemonOgre::Server.debug
-          when "stop"     then serv_load.push  "stop"
-          when "restart"  then serv_load.push  "restart"
-          when "reset"    then serv_load.push  "restart"
-          when "debugger" then serv_load.push  "debugger"
-          when "log"      then DaemonOgre::Server.set_log  "log"
-          when "pid"      then DaemonOgre::Server.set_pid  "pid"
-          when "-l"       then DaemonOgre::Server.set_log  "-l"
-          when "-p"       then DaemonOgre::Server.set_pid  "-p"
-          when "port"     then DaemonOgre::Server.set_port "port"
-          when "-tcp"     then DaemonOgre::Server.set_port "-tcp"
-          when "status"   then DaemonOgre::Server.pid_check
-          when "-s"       then DaemonOgre::Server.pid_check
-          when "help"     then DaemonOgre::Server.help
-          when "debug"    then DaemonOgre::Server.debug
-          when "clear"    then serv_load.push "clear"
-
-        end
-      end
-
-      #server_TODO
-      begin
-        DaemonOgre::Server.restart      if serv_load.include? "restart"
-        DaemonOgre::Server.start        if serv_load.include? "start"
-        DaemonOgre::Server.stop         if serv_load.include? "stop"
-        DaemonOgre::Server.clear        if serv_load.include? "clear"
-        DaemonOgre::Server.daemon       if serv_load.include? "daemon"
-      end
-
-      #Continue our program ? : )
-      DaemonOgre::Server.continue? if DaemonOgre::App.terminate
-
-      begin
-        require "debugger" ;debugger if serv_load.include? "debugger"
-      rescue Exception => ex
-        puts "you need to install debugger gem => gem install debugger\n#{ex}"
-      end
-
-    end
-  end
-  def self.help
-    puts "\n##defaults:\narg[:log_path]\tlog path and"+\
-    " file name\narg[:pid_path]\tpid path and file n"+\
-    "ame\narg[:terminate]\tstart command required to"+\
-    " continue? 'ruby xy.rb start'\narg[:name]\tapplication names as daemon process"
-  end
-end