raemon 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2009 NuLayer Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,20 @@
+Raemon
+======
+
+Raemon is a Ruby framework for building daemons. It's designed for writing
+master/worker pre-forking servers running on UNIX. More to come.
+
+
+Credits
+-------
+By: Peter Kieltyka
+Copyright (c) 2007-2009 NuLayer Inc. All rights reserved.
+
+
+Thanks
+------
+Raemon was influenced by the following projects:
+
+servolux   - http://github.com/TwP/servolux
+daemon_kit - http://github.com/kennethkalmer/daemon-kit
+rails      - http://github.com/rails/rails

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "raemon"
+    gem.summary     = "Raemon is a Ruby framework for building UNIX daemons."
+    gem.description = "Raemon is a Ruby framework for building UNIX daemons."
+    gem.email       = "peter.kieltyka@nulayer.com"
+    gem.homepage    = "http://github.com/pkieltyka/raemon"
+    gem.authors     = ["Peter Kieltyka"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/beanstalk.rb

@@ -0,0 +1,51 @@
+$:.unshift ::File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'raemon'
+require 'beanstalk-client'
+
+class Test
+  include Raemon::Worker
+  
+  def start
+    logger.info "=> Starting worker #{Process.pid}"
+    
+    @beanstalk = Beanstalk::Pool.new(['localhost:11300'])
+  end
+  
+  def stop
+    logger.info "=> Stopping worker #{Process.pid}"
+    
+    @beanstalk.close
+    exit
+  end
+  
+  def execute
+    loop do
+      stop if shutting_down?
+    
+      begin
+        job = @beanstalk.reserve(2)
+      rescue Beanstalk::TimedOut
+      end
+      
+      if job
+        logger.info "(#{Process.ppid}:#{Process.pid}) got job: #{job.inspect}"
+        
+        # process job here ...
+        job.delete
+      end
+    end
+  end
+
+end
+
+ROOT_DIR = '/Users/peter/Desktop'
+
+# Raemon::Master.startup 3, Test, {
+#   :detach   => true,
+#   :logger   => Logger.new("#{ROOT_DIR}/beanstalk.log"),
+#   :pid_file => "#{ROOT_DIR}/beanstalk.pid"
+# }
+
+Raemon::Master.startup 3, Test

data/examples/sampled/bin/sampled

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+# Setup environment
+case ARGV.first
+when nil
+  ENV['RAEMON_ENV'] = 'development'
+when 'start'
+  ENV['RAEMON_ENV'] = 'production'
+when 'stop'
+  @shutdown = true
+end
+
+# Load Raemon Server
+require File.dirname(__FILE__) + '/../config/environment'
+
+if @shutdown
+  Raemon::Server.shutdown!
+else
+  Raemon::Server.startup!
+end

data/examples/sampled/config/boot.rb

@@ -0,0 +1,30 @@
+# Don't change this file!
+# Configure your daemon in config/environment.rb
+
+RAEMON_ROOT = File.expand_path(File.dirname(__FILE__)+'/..') unless defined?(RAEMON_ROOT)
+
+module Raemon
+  class << self
+    def boot!
+      return if defined? Raemon::Server
+      
+      load_vendor_libs
+      
+      require 'rubygems'
+      require 'raemon'
+      
+      Raemon::Server.run
+    end
+    
+    def load_vendor_libs
+      Dir.entries("#{RAEMON_ROOT}/vendor").each do |vendor|
+        vendor_lib = "#{RAEMON_ROOT}/vendor/#{vendor}/lib"
+        if File.directory?(vendor_lib) && vendor != '..'
+          $LOAD_PATH.unshift vendor_lib
+        end
+      end
+    end
+  end
+end
+
+Raemon.boot!

data/examples/sampled/config/environment.rb

@@ -0,0 +1,16 @@
+# Be sure to restart your daemon when you modify this file
+
+# Uncomment below to force your daemon into production mode
+#ENV['DAEMON_ENV'] ||= 'production'
+
+require File.join(File.dirname(__FILE__), 'boot')
+
+require 'ruby-debug'
+
+Raemon::Server.run do |config|
+  config.name         = 'Sampled'
+  config.worker_klass = 'Sampled::Worker'
+  config.num_workers  = 1
+  
+  config.log_level    = :info
+end

data/examples/sampled/config/environments/development.rb

@@ -0,0 +1,5 @@
+config.detach       = false
+config.num_workers  = 2
+config.log_level    = :debug
+
+require 'ruby-debug'

data/examples/sampled/config/environments/production.rb

@@ -0,0 +1,3 @@
+config.detach       = true
+config.num_workers  = 2
+config.log_level    = :warn

data/examples/sampled/config/environments/test.rb

@@ -0,0 +1 @@
+config.log_level = :debug

data/examples/sampled/config/initializers/settings.rb

@@ -0,0 +1,2 @@
+require 'yaml'
+SETTINGS = YAML.load(File.read(RAEMON_ROOT + "/config/settings.yml"))[RAEMON_ENV]

data/examples/sampled/config/settings.yml

@@ -0,0 +1,8 @@
+development:
+    peter: true
+
+production:
+    peter: false
+    
+test:
+    peter: true

data/examples/sampled/lib/sampled.rb

@@ -0,0 +1,25 @@
+module Sampled
+  
+  class Worker
+    include Raemon::Worker
+    
+    def start
+      logger.info "Start .. #{Process.ppid}:#{Process.pid}"
+    end
+
+    def stop
+      logger.info "=> Stopping worker #{Process.pid}"
+      exit
+    end
+
+    def execute
+      loop do
+        stop if shutting_down?
+
+        logger.warn "I'm executing .. #{Process.ppid}:#{Process.pid}"
+        sleep 2
+      end
+    end
+  end
+  
+end

data/examples/test.rb

@@ -0,0 +1,31 @@
+$:.unshift ::File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'raemon'
+
+class Test
+  include Raemon::Worker
+  
+  def start
+    logger.info "=> Starting worker #{Process.pid}"
+  end
+
+  def stop
+    logger.info "=> Stopping worker #{Process.pid}"
+    exit
+  end
+
+  def execute
+    loop do
+      stop if shutting_down?
+    
+      logger.warn "I'm executing .. #{Process.ppid}:#{Process.pid}"
+      sleep 2
+    end
+  end
+
+end
+
+ROOT_DIR = '/Users/peter/Desktop'
+
+Raemon::Master.startup 3, Test

data/lib/raemon/master.rb

@@ -0,0 +1,80 @@
+module Raemon
+  class Master
+    attr_reader :worker_pids
+    attr_reader :worker_klass
+    attr_reader :logger
+    
+    def self.startup(num_workers, worker_klass, opts={})
+      master = new(opts)
+      master.startup(num_workers, worker_klass)
+    end
+    
+    def self.shutdown(pid_file)
+      pid = File.open(pid_file, 'r') {|f| f.gets }.to_i
+      Process.kill('TERM', pid) if pid > 0
+      File.unlink(pid_file)
+    rescue Errno::ESRCH
+    end
+    
+    def initialize(opts={})
+      @detach         = opts[:detach] || false
+      @logger         = opts[:logger] || Logger.new(STDOUT)
+      @pid_file       = opts[:pid_file]
+      @worker_pids    = []
+      
+      daemonize if @detach
+    end
+    
+    def startup(num_workers, worker_klass)
+      logger.info "=> Starting Raemon::Master with #{num_workers} worker(s)"
+      
+      @worker_klass = worker_klass
+      
+      # Check if the worker implements our protocol
+      if !worker_klass.include?(Raemon::Worker)
+        logger.error "** Invalid Raemon worker"
+        exit
+      end
+      
+      # Spawn workers
+      num_workers.times { worker_pids << worker_klass.start!(self) }
+      
+      # Setup signals for the master process
+      setup_signals
+      
+      # Wait for all the workers
+      Process.waitall
+      
+      logger.close
+    end
+    
+    def shutdown
+      @worker_pids.each { |wpid| worker_klass.stop!(wpid) }
+    end
+    
+    def daemonize
+      exit if Kernel.fork
+      
+      Process.setsid
+    
+      Dir.chdir '/'
+      File.umask 0000
+
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen '/dev/null', 'a'
+      
+      File.open(@pid_file, 'w') { |f| f.puts(Process.pid) } if @pid_file
+    end
+    
+    def setup_signals
+      shutdown_block = Proc.new { shutdown }
+      
+      trap('INT', shutdown_block)
+      trap('TERM', shutdown_block)
+    end
+    
+    def debugging?; @debug; end
+    
+  end
+end

data/lib/raemon/server.rb

@@ -0,0 +1,106 @@
+RAEMON_ENV = (ENV['RAEMON_ENV'] || 'development').dup unless defined?(RAEMON_ENV)
+
+module Raemon
+  module Server
+    
+    class << self
+      attr_accessor :config
+      
+      def run
+        @config = Configuration.new if config.nil?
+        yield config if block_given?
+      end
+      
+      def startup!
+        load_environment
+        load_initializers
+        load_lib
+        
+        initialize_logger
+
+        # Check if the server is already running
+        if running?
+          STDERR.puts "Error: #{server_name} is already running."
+          exit
+        end
+
+        # Start the master daemon
+        config.logger.info "=> Booting #{server_name} (#{RAEMON_ENV})"
+        
+        worker_klass = instance_eval(config.worker_klass)
+        
+        Raemon::Master.startup config.num_workers, worker_klass, {
+          :detach   => config.detach,
+          :logger   => config.logger,
+          :pid_file => pid_file
+        }
+      end
+      
+      def shutdown!
+        Raemon::Master.shutdown pid_file
+      end
+      
+      def initialize_logger
+        return if !config.logger.nil?
+        
+        if config.detach
+          config.logger = Logger.new("#{RAEMON_ROOT}/log/#{server_name_key}.log")
+        else
+          config.logger = Logger.new(STDOUT)
+        end
+        
+        # TODO: format the logger
+        # config.logger.format
+      end
+      
+      def load_environment
+        environment_file = "#{RAEMON_ROOT}/config/environments/#{RAEMON_ENV}.rb"
+        eval IO.read(environment_file), binding
+      end
+      
+      def load_initializers
+        load_folder("#{RAEMON_ROOT}/config/initializers")
+      end
+
+      def load_lib
+        load_folder("#{RAEMON_ROOT}/lib")
+      end
+      
+      def load_folder(path)
+        Dir.entries(path).each do |lib_file|
+          if lib_file != '.' && lib_file != '..'
+            require "#{path}/#{lib_file}"
+          end
+        end
+      end
+      
+      def server_name
+        @server_name = config.name || 'Raemon'
+      end
+      
+      def server_name_key
+        server_name.downcase.gsub(' ', '_')
+      end
+      
+      def pid_file
+        "#{RAEMON_ROOT}/tmp/pids/#{server_name_key}.pid"
+      end
+      
+      def running?
+        # TODO
+        false
+      end
+    end
+    
+    class Configuration
+      ATTRIBUTES = [ :name, :detach, :worker_klass, :num_workers, :log_level, :logger ]
+
+      attr_accessor *ATTRIBUTES
+      
+      def [](key)
+        send key rescue nil
+      end
+    end
+    
+  end
+end

data/lib/raemon/worker.rb

@@ -0,0 +1,53 @@
+module Raemon
+  module Worker
+    
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def start!(master=nil)
+        child_pid = Kernel.fork do
+          # Child process
+          worker = new(master)
+          worker.execute
+        end
+        
+        # Parent returns the worker's pid
+        return child_pid
+      end
+    
+      def stop!(worker_pid)
+        Process.kill('QUIT', worker_pid) rescue nil
+      end
+    end
+    
+    module InstanceMethods
+      attr_reader :logger
+      
+      def initialize(master=nil)
+        @master = master
+        @logger = master.logger if master
+        
+        setup_signals
+        start
+      end
+        
+      def start;                                      end
+      def stop;                                       end
+      def shutting_down?;   @shutting_down;           end
+      def execute;          raise "Abstract method";  end
+
+      def setup_signals
+        quit_block = Proc.new { @shutting_down = true }
+        force_quit_block = Proc.new { exit }
+
+        trap('QUIT', quit_block)
+        trap('TERM', force_quit_block)
+        trap('INT') {} # Reset INT signal handler
+      end
+    end
+    
+  end
+end

data/lib/raemon.rb

@@ -0,0 +1,10 @@
+require 'socket'
+require 'logger'
+
+module Raemon
+  VERSION = '0.1'
+end
+
+require 'raemon/server'
+require 'raemon/master'
+require 'raemon/worker'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: raemon
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Peter Kieltyka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-26 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Raemon is a Ruby framework for building UNIX daemons.
+email: peter.kieltyka@nulayer.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- .gitignore
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- examples/beanstalk.rb
+- examples/sampled/bin/sampled
+- examples/sampled/config/boot.rb
+- examples/sampled/config/environment.rb
+- examples/sampled/config/environments/development.rb
+- examples/sampled/config/environments/production.rb
+- examples/sampled/config/environments/test.rb
+- examples/sampled/config/initializers/settings.rb
+- examples/sampled/config/settings.yml
+- examples/sampled/lib/sampled.rb
+- examples/test.rb
+- lib/raemon.rb
+- lib/raemon/master.rb
+- lib/raemon/server.rb
+- lib/raemon/worker.rb
+has_rdoc: true
+homepage: http://github.com/pkieltyka/raemon
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Raemon is a Ruby framework for building UNIX daemons.
+test_files: 
+- examples/beanstalk.rb
+- examples/sampled/config/boot.rb
+- examples/sampled/config/environment.rb
+- examples/sampled/config/environments/development.rb
+- examples/sampled/config/environments/production.rb
+- examples/sampled/config/environments/test.rb
+- examples/sampled/config/initializers/settings.rb
+- examples/sampled/lib/sampled.rb
+- examples/test.rb