forever 0.0.8

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in forever.gemspec
+gemspec

data/README.md

@@ -0,0 +1,114 @@
+# Forever
+
+Small daemon framework for ruby, with logging, error handler watcher and much more.
+
+## Why?
+
+There are a lot of alternatives, one of the best is [resque](https://github.com/defunkt/resque), so why another daemons framework?
+In my servers I've several daemons and what I need is:
+
+* easily watch the process (memory, cpu)
+* easily manage exceptions
+* easily see logs
+* easily start/stop/restart daemon
+
+As like [sinatra](https://github.com/sinatra/sinatra) and [padrino](https://github.com/padrino/padrino-framework) I need a
+**thin** framework to do these jobs in few seconds. This mean that:
+
+1) I can create a new job quickly
+2) I can watch, start, stop it quickly
+
+So, if you have my needs, **Forever** can be the right choice for you.
+
+## Install:
+
+``` sh
+$ gem install forever
+```
+
+## Deamon Example:
+
+Place your script under your standard directory, generally on my env is _bin_ or _scripts_.
+
+In that case is: ```bin/foo```
+
+``` rb
+#!/usr/bin/ruby
+require 'rubygems' unless defined?(Gem)
+require 'forever'
+require 'mail'
+
+Forever.run do
+  ##
+  # You can set these values:
+  #
+  # dir  "foo"     # Default: File.expand_path('../../', __FILE__)
+  # file "bar"     # Default: __FILE__
+  # log  "bar.log" # Default: File.expand_path(dir, '/log/[file_name].log')
+  # pid  "bar.pid" # Default: File.expand_path(dir, '/tmp/[file_name].pid')
+  #
+
+  on_error do |e|
+    Mail.deliver do
+      delivery_method :sendmail, :location => `which sendmail`.chomp
+      to      "d.dagostino@lipsiasoft.com"
+      from    "exceptions@lipsiasoft.com"
+      subject "[Foo Watcher] #{e.message}"
+      body    "%s\n  %s" % [e.message, e.backtrace.join("\n  ")]
+    end
+  end
+
+  on_ready do
+    require 'bundler/setup'
+    require 'foo'
+    Foo.start_loop
+  end
+end
+```
+
+Assign right permission:
+
+``` sh
+$ chmod +x bin/foo
+```
+
+start the daemon:
+
+``` sh
+$ bin/foo
+```
+
+you should see an output like:
+
+```
+$ bin/foo
+=> Process demonized with pid 19538
+```
+
+you can stop it:
+
+```
+$ bin/foo stop
+=> Found pid 19538...
+=> Killing process 19538...
+```
+
+## Monitor your daemon(s):
+
+List daemons:
+
+```
+$ forever list
+PID     RSS     CPU   CMD
+19838   32512   1.6   Forever: bin/githubwatcher
+```
+
+Stop daemon(s):
+
+```
+$ forever stop foo
+Do you want really stop Forever: bin/foo  with pid 19538? y
+Killing process Forever: bin/foo  with pid 19538...
+```
+
+That's all!

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler/gem_tasks'
+
+task :clean do
+  `rm -rf pkg`
+end

data/bin/forever

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby
+require 'rubygems' unless defined?(Gem)
+require File.expand_path('../../lib/forever/version.rb', __FILE__)
+require 'thor'
+
+class CLI < Thor
+  desc "list", "List Forever daemons"
+  def list
+    say "PID\tRSS\tCPU\tCMD", :green
+    puts daemons.join("\n")
+  end
+
+  desc "stop [DAEMON]", "Stop a specified daemon"
+  def stop(daemon)
+    found = daemons.find_all { |d| d=~/#{daemon}/i }
+    say "Daemon(s) matching '#{daemon}' not found", :red if found.empty?
+    found.each do |daemon|
+      daemon = daemon.split("\t")
+      if yes? "Do you want really stop #{daemon[-1]} with pid #{daemon[0]}?"
+        say "Killing process #{daemon[-1]} with pid #{daemon[0]}...", :green
+        result = `kill #{daemon[0]}`.strip
+        say result, :red if result != ""
+      end
+    end
+  end
+
+  private
+    def daemons
+      `ps axo pid,rss,pcpu,command | grep -vE "^USER|grep" | grep Forever: | awk '{print $1"\t"$2"\t"$3"\t"$4" "$5" "$6}'`.chomp.split("\n")
+    end
+end
+
+ARGV << "-h" if ARGV.empty?
+CLI.start(ARGV)

data/forever.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "forever/version"
+
+Gem::Specification.new do |s|
+  s.name        = "forever"
+  s.version     = Forever::VERSION
+  s.authors     = ["DAddYE"]
+  s.email       = ["d.dagostino@lipsiasoft.com"]
+  s.homepage    = "https://github.com/daddye/forever"
+  s.summary     = %q{Small daemon framework for ruby}
+  s.description = %q{Small daemon framework for ruby, with logging, error handler and more...}
+
+  s.rubyforge_project = "forever"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency 'thor', '~>0.14.6'
+end

data/lib/forever.rb

@@ -0,0 +1,12 @@
+require "forever/base"
+
+module Forever
+  extend self
+
+  def run(options={}, &block)
+    caller_file = caller(1).map { |line| line.split(/:(?=\d|in )/)[0,1] }.flatten.first
+    options[:dir]    ||= File.expand_path('../../', caller_file) # => we presume we are calling it from a bin|script dir
+    options[:file]   ||= File.expand_path(caller_file)
+    Base.new(options, &block)
+  end # run
+end # Forever

data/lib/forever/base.rb

@@ -0,0 +1,126 @@
+require 'fileutils'
+
+module Forever
+  class Base
+    def initialize(options={}, &block)
+      options.each { |k,v| send(k, v) }
+
+      Dir.chdir(dir) if exists?(dir)
+      FileUtils.mkdir(File.dirname(log), :noop => true) if exists?(log)
+      FileUtils.mkdir(File.dirname(pid), :noop => true) if exists?(pid)
+
+      instance_eval(&block)
+
+      stop!
+
+      return if ARGV[0] == "stop" || on_ready.nil?
+
+      fork do
+        $0 = "Forever: #{$0}"
+        puts "=> Process demonized with pid #{Process.pid}"
+
+        %w(INT TERM KILL).each { |signal| trap(signal)  { stop! } }
+
+        File.open(pid, "w") { |f| f.write(Process.pid.to_s) }
+
+        stream      = exists?(log) ? File.new(log, "w") : '/dev/null'
+        stream.sync = true
+
+        STDOUT.reopen(stream)
+        STDERR.reopen(STDOUT)
+
+        begin
+          on_ready.call
+        rescue Exception => e
+          Thread.list.reject { |t| t==Thread.current }.map(&:kill)
+          on_error[e] if on_error
+          stream.print "\n\n%s\n  %s\n\n" % [e.message, e.backtrace.join("\n  ")]
+          sleep 30
+          retry
+        end
+      end
+    end
+
+    ##
+    # Caller file
+    #
+    def file(value=nil)
+      value ? @_file = value : @_file
+    end
+
+    ##
+    # Base working Directory
+    #
+    def dir(value=nil)
+      value ? @_dir = value : @_dir
+    end
+
+    ##
+    # File were we redirect STOUT and STDERR, can be false.
+    #
+    # Default: dir + 'log/[process_name].log'
+    #
+    def log(value=nil)
+      @_log ||= File.join(dir, "log/#{File.basename(file)}.log") if exists?(dir, file)
+      value ? @_log = value : @_log
+    end
+
+    ##
+    # File were we store pid
+    #
+    # Default: dir + 'tmp/[process_name].pid'
+    #
+    def pid(value=nil)
+      @_pid ||= File.join(dir, "tmp/#{File.basename(file)}.pid") if exists?(dir, file)
+      value ? @_pid = value : @_pid
+    end
+
+    ##
+    # Search if there is a running process and stop it
+    #
+    def stop!(kill=true)
+      if exists?(pid)
+        _pid = File.read(pid).to_i
+        puts "=> Found pid #{_pid}..."
+        FileUtils.rm_f(pid)
+        begin
+          puts "=> Killing process #{_pid}..."
+          Process.kill(:KILL, _pid)
+        rescue Errno::ESRCH => e
+          puts "=> #{e.message}"
+        end
+      else
+        puts "=> Pid not found, process seems don't exist!"
+      end
+    end
+
+    ##
+    # Callback raised when an error occour
+    #
+    def on_error(&block)
+      block_given? ? @_on_error = block : @_on_error
+    end
+
+    ##
+    # Callback to fire when the daemon start
+    #
+    def on_ready(&block)
+      block_given? ? @_on_error = block : @_on_error
+    end
+
+    def to_s
+      "#<Forever dir:#{dir}, file:#{file}, log:#{log}, pid:#{pid}>"
+    end
+    alias :inspect :to_s
+
+    def config
+      { :dir => dir, :file => file, :log => log, :pid => pid }.to_yaml
+    end
+    alias :to_yaml :config
+
+    private
+      def exists?(*values)
+        values.all? { |value| value && File.exist?(value) }
+      end
+  end # Base
+end # Forever

data/lib/forever/version.rb

@@ -0,0 +1,3 @@
+module Forever
+  VERSION = "0.0.8"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: forever
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
+platform: ruby
+authors: 
+- DAddYE
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 14
+        - 6
+        version: 0.14.6
+  type: :runtime
+  version_requirements: *id001
+description: Small daemon framework for ruby, with logging, error handler and more...
+email: 
+- d.dagostino@lipsiasoft.com
+executables: 
+- forever
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/forever
+- forever.gemspec
+- lib/forever.rb
+- lib/forever/base.rb
+- lib/forever/version.rb
+has_rdoc: true
+homepage: https://github.com/daddye/forever
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: forever
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Small daemon framework for ruby
+test_files: []
+