raad_totem 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6cc5ec492a3a7e4ff5ee49cf38c01826f0efb27
+  data.tar.gz: df041b77a669ce3a6abf6443f9a186ef215a775d
+SHA512:
+  metadata.gz: 8aaf81a66fbe9eb507da57698f2d36f49507f49f3af90dfd3cda219d39222b2426f226a13660d242ae8c11242d122eef060822b87eb48da5e66882fb34cb4eed
+  data.tar.gz: 76cb583b22e8bbbc7981edf97b5566c3ebaf480e5d237c67eafc08dabb2f825f81b55cff52b96ab4a640eae8cf79b549ba7f6bc0d073cec2f43ac1e695c47ef3

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.ruby-gemset
+.rvmrc
+test/validation/output/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - jruby-18mode
+  - jruby-19mode

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+# 0.0.1 03-14-2014
+- Fork project and name it raad_totem.
+- From this point forward, this Changelog will not be updated.  Read git log instead.
+
+# 0.3.1, 08-24-2011
+- initial release. support for MRI 1.8 & 1.9 only
+
+# 0.3.3, 08-26-2011
+- reworked runner stop sequence & signals trapping
+- force kill + pid removal bug
+- wrong exit code bug
+- comments & cosmetics
+
+# 0.4.0, 09-13-2011
+- using SignalTrampoline for safe signal handling
+- JRuby support
+- specs and validations for all supported rubies
+- tested on MRI 1.8.7 & 1.9.2, REE 1.8.7, JRuby 1.6.4 under OSX 10.6.8 and Linux Ubuntu 10.04
+
+# 0.4.1, 09-22-2011
+- issue #1, allow arbitrary environment name, https://github.com/praized/raad/issues/1
+- issue #3, avoid calling stop multiple times,  https://github.com/praized/raad/issues/3
+- added Raad.stopped?
+
+# 0.5.0, 10-12-2011
+- issue #4, allow logger usage in service initialize method, https://github.com/praized/raad/issues/4
+- issue #7, Raad.env not correct in service.initialize, https://github.com/praized/raad/issues/7
+- refactored Runner initialize/run/start_service methods
+- custom options now uses options_parser class method in the service
+- added examples/custom_options.rb

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    raad_totem (0.0.1)
+      totem (>= 0.0.5)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rake (10.1.1)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    totem (0.0.5)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  raad_totem!
+  rake
+  rspec (~> 2.8.0)

data/LICENSE.md

@@ -0,0 +1,103 @@
+Raad - Totem
+Authored by Chad Remesch (chad@remesch.com) as a derivate of the original Raad Ruby gem.
+
+  Copyright 2014 Chad Remesch
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+-------------------------------------------------------------------------------
+
+Raad - Ruby as a Daemon lightweight service wrapper
+Authored by Colin Surprenant, [@colinsurprenant][twitter], [colin.surprenant@needium.com][needium], [colin.surprenant@gmail.com][gmail], [http://github.com/colinsurprenant][github]
+
+  Copyright 2011 PraizedMedia Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Thin project (https://github.com/macournoyer/thin) and under the following license:
+  Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Goliath project (https://github.com/postrank-labs/goliath/) and under the following license:
+  Copyright (c) 2011 PostRank Inc.
+
+  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 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.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Sinatra project (https://github.com/bmizerany/sinatra) and under the following license:
+  Copyright (c) 2007, 2008, 2009, 2010, 2011 Blake Mizerany
+
+  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.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Spoon project https://github.com/headius/spoon) and under the following license:
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+[needium]: colin.surprenant@needium.com
+[gmail]: colin.surprenant@gmail.com
+[twitter]: http://twitter.com/colinsurprenant
+[github]: http://github.com/colinsurprenant

data/README.md

@@ -0,0 +1,37 @@
+# Raad - Totem
+
+This gem allows you to easily create daemons (also known as servers, services, or background processes) in a project generated with [Totem](https://github.com/chadrem/totem).  Both MRI and Jruby are supported.
+
+This is a fork of the [Raad](https://github.com/colinsurprenant/raad) gem that is modified for Totem projects.  All credit goes to the original project as they did all the hard work.
+
+## Changes from the original Raad v0.5.0:
+
+- Removal of log4j since Totem already has a built in logger.
+- Integration with Totem's environment setting.
+- Change namespaces so as not to conflict with Raad if both gems are installed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'raad-totem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install raad-totem
+
+## Usage
+
+Coming soon.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+
+task :default => :spec
+
+begin
+  require 'rspec/core/rake_task'
+  desc 'run specs in the current ruby env'
+  task :spec do
+    sh 'ruby -v'
+    RSpec::Core::RakeTask.new
+  end
+rescue NameError, LoadError => e
+  puts e
+end

data/lib/raad_totem/bootstrap.rb

@@ -0,0 +1,67 @@
+module RaadTotem
+
+  # The bootstrap class for RaadTotem. This will execute in the at_exit
+  # handler to run the service.
+  class Bootstrap
+
+    CALLERS_TO_IGNORE = [ # :nodoc:
+      /\/raad_totem(\/(bootstrap))?\.rb$/,    # all raad code
+      /rubygems\/custom_require\.rb$/,        # rubygems require hacks
+      /bundler(\/runtime)?\.rb/,              # bundler require hacks
+      /<internal:/                            # internal in ruby >= 1.9.2
+    ]
+
+    CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
+    # Like Kernel#caller but excluding certain magic entries and without
+    # line / method information; the resulting array contains filenames only.
+    def self.caller_files
+      caller_locations.map { |file, line| file }
+    end
+
+    # like caller_files, but containing Arrays rather than strings with the
+    # first element being the file, and the second being the line.
+    def self.caller_locations
+      caller(1).
+        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+        reject { |file, line| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
+    end
+
+    # find the service_file that was used to execute the service
+    #
+    # @return [String] The service file
+    def self.service_file
+      c = caller_files.first
+      c = $0 if !c || c.empty?
+      c
+    end
+
+    # execute the service
+    #
+    # @return [Nil]
+    def self.run!
+      service_class = Object.module_eval(camel_case(File.basename(service_file, '.rb')))
+      Runner.new(ARGV, service_class).run
+    end
+
+    private
+
+    # convert a string to camel case
+    #
+    # @param str [String] The string to convert
+    # @return [String] The camel cased string
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+
+      str.split('_').map { |e| e.capitalize }.join
+    end
+  end
+
+  at_exit do
+    unless defined?($RAAD_TOTEM_NOT_RUN)
+      if $!.nil? && $0 == RaadTotem::Bootstrap.service_file
+        RaadTotem::Bootstrap.run!
+      end
+    end
+  end
+end

data/lib/raad_totem/env.rb

@@ -0,0 +1,61 @@
+require 'rbconfig'
+require 'thread'
+
+module RaadTotem
+
+  @custom_options = {}
+  @stopped = false
+  @stop_lock = Mutex.new
+
+  # are we running inside jruby
+  #
+  # @return [Boolean] true if runnig inside jruby
+  def jruby?
+    !!(defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby')
+  end
+
+  # absolute path of current interpreter
+  #
+  # @return [String] absolute path of current interpreter
+  def ruby_path
+    File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["RUBY_INSTALL_NAME"] + RbConfig::CONFIG["EXEEXT"])
+  end
+
+  # ruby interpreter command line options
+  #
+  # @return [Array] command line options list
+  def ruby_options
+    @ruby_options ||= []
+  end
+
+  # set ruby interpreter command line options
+  #
+  # @param [String] options_str space separated options list
+  def ruby_options=(options_str)
+    @ruby_options = options_str.split
+  end
+
+  # a request to stop the service has been received (or the #start method has returned and, if defined, the service #stop method has been called by RaadTotem.
+  #
+  # @return [Boolean] true is the service has been stopped
+  def stopped?
+    @stop_lock.synchronize{@stopped}
+  end
+
+  # used internally to set the stopped flag
+  #
+  # @param [Boolean] state true to set the stopped flag
+  def stopped=(state)
+    @stop_lock.synchronize{@stopped = !!state}
+  end
+
+  # returns the custom options hash set in the service options_parser class method
+  #
+  # @return [Hash] custom options hash
+  def custom_options
+    @custom_options
+  end
+
+  module_function :jruby?, :ruby_path, :ruby_options, :ruby_options=, :stopped?, :stopped=, :custom_options
+
+end

data/lib/raad_totem/runner.rb

@@ -0,0 +1,195 @@
+require 'optparse'
+require 'timeout'
+require 'thread'
+require 'fileutils'
+
+module RaadTotem
+  class Runner
+    include Daemonizable
+
+    SECOND = 1
+    STOP_TIMEOUT = 60 * SECOND
+
+    attr_accessor :pid_file
+
+    # Create a new Runner
+    #
+    # @param argv [Array] command line arguments
+    # @param service_class [Class] service class
+    def initialize(argv, service_class)
+      @argv = argv.dup # lets keep a copy for jruby double-launch
+      @service_class = service_class
+      @parsed_options = nil
+
+      @stop_lock = Mutex.new
+      @stop_signaled = false
+
+      # parse command line options and set @parsed_options
+      options_parser = service_class.respond_to?(:options_parser) ? service_class.options_parser(create_options_parser, RaadTotem.custom_options) : create_options_parser
+      begin
+        options_parser.parse!(argv)
+      rescue OptionParser::InvalidOption => e
+        puts(">> #{e.message}")
+        exit!(false)
+      end
+
+      # grab what's left after options, which should be the start/stop command
+      @parsed_options[:command] = argv[0].to_s.downcase
+      unless ['start', 'stop', 'post_fork'].include?(@parsed_options[:command])
+        puts(">> start|stop command is required")
+        exit!(false)
+      end
+
+      Totem.component = default_service_name(service_class)
+
+      # @pid_file is required to become Daemonizable
+      @pid_file = @parsed_options.delete(:pid_file) || default_pid_path
+      FileUtils.mkdir_p(File.dirname(@pid_file))
+
+      # default stop timeout
+      @stop_timeout = (@parsed_options.delete(:stop_timeout) || STOP_TIMEOUT).to_i
+    end
+
+    def run
+      # check for stop command, @pid_file must be set
+      if @parsed_options[:command] == 'stop'
+        puts(">> RaadTotem service wrapper v#{VERSION} stopping")
+        # first send the TERM signal which will invoke the daemon wait_or_will method which will timeout after @stop_timeout
+        # if still not stopped afer @stop_timeout + 2 seconds, KILL -9 will be sent.
+        success = send_signal('TERM', @stop_timeout + (2 * SECOND))
+        exit(success)
+      end
+
+      Dir.chdir(File.expand_path(File.dirname("./")))
+
+      if @parsed_options[:command] == 'post_fork'
+        # we've been spawned and re executed, finish setup
+        post_fork_setup(Totem.component, (@parsed_options[:redirect] || default_redirect_path))
+        start_service
+      else
+        puts(">> RaadTotem service wrapper v#{VERSION} starting")
+        @parsed_options[:daemonize] ? daemonize(@argv, Totem.component, @parsed_options[:redirect]) {start_service} : start_service
+      end
+    end
+
+    private
+
+    def default_redirect_path
+      return File.join(Totem.root, 'log', "#{Totem.process_name}.stdout")
+    end
+
+    def default_pid_path
+      return File.join(Totem.root, 'tmp', 'pid', "#{Totem.process_name}.pid")
+    end
+
+    def start_service
+      Totem.logger.debug("initializing #{Totem.component} service")
+
+      # create service instance
+      service = @service_class.new
+
+      # important to display this after service instantiation.
+      Totem.logger.info("starting #{Totem.component} service")
+
+      at_exit do
+        Totem.logger.info(">> RaadTotem service wrapper stopped")
+      end
+
+      # do not trap :QUIT because its not supported in jruby
+      [:INT, :TERM].each{|sig| SignalTrampoline.trap(sig) {stop_service(service)}}
+
+      # launch the service thread and call start. we expect start not to return
+      # unless it is done or has been stopped.
+      service_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        service.start
+        stop_service(service)
+      end
+
+      result = wait_or_kill(service_thread)
+      # if not daemonized start a sentinel thread, if still alive after 2 seconds, do arakiri
+      Thread.new{sleep(2 * SECOND);  Process.kill(:KILL, Process.pid)} unless @parsed_options[:daemonize]
+      # use exit and not exit! to make sure the at_exit hooks are called, like the pid cleanup, etc.
+      exit(result)
+    end
+
+    def stop_service(service)
+      return if @stop_lock.synchronize{s = @stop_signaled; @stop_signaled = true; s}
+
+      Totem.logger.info("stopping #{Totem.component} service")
+      service.stop if service.respond_to?(:stop)
+      RaadTotem.stopped = true
+    end
+
+    # try to do a timeout join periodically on the given thread. if the join succeed then the stop
+    # sequence is successful and return true.
+    # Otherwise, on timeout if stop has beed signaled, wait a maximum of @stop_timeout on the
+    # thread and kill it if the timeout is reached and return false in that case.
+    #
+    # @return [Boolean] true if the thread normally terminated, false if a kill was necessary
+    def wait_or_kill(thread)
+      while thread.join(SECOND).nil?
+        # the join has timed out, thread is still buzzy.
+        if @stop_lock.synchronize{@stop_signaled}
+          # but if stop has been signalled, start "the final countdown" ♫
+          try = 0; join = nil
+          while (try += 1) <= @stop_timeout && join.nil? do
+            join = thread.join(SECOND)
+            Totem.logger.debug("waiting for service to stop #{try}/#{@stop_timeout}") if join.nil?
+          end
+          if join.nil?
+            Totem.logger.error("stop timeout exhausted, killing service thread")
+            thread.kill
+            return false
+          end
+          return true
+        end
+      end
+      true
+    end
+
+    # convert the service class name from CameCase to underscore
+    #
+    # @return [String] underscored service class name
+    def default_service_name(clazz)
+      clazz.to_s.split('::').last.gsub(/(.)([A-Z])/,'\1_\2').downcase!
+    end
+
+    # Create the options parser
+    #
+    # @return [OptionParser] Creates the options parser for the runner with the default options
+    def create_options_parser
+      @parsed_options ||= {
+        :daemonize => false
+      }
+
+      options_parser ||= OptionParser.new do |opts|
+        opts.banner = "USAGE: ruby <service>.rb [options] start|stop"
+
+        opts.separator ""
+        opts.separator "Service Options:"
+
+        opts.on('-d', '--daemonize', "run daemonized in the background (default: no)") { |v| @parsed_options[:daemonize] = v }
+        opts.on('-P', '--pid FILE', "pid file when daemonized (default: tmp/pids directory)") { |file| @parsed_options[:pid_file] = file }
+        opts.on('-r', '--redirect FILE', "redirect stdout when daemonized (default: log directory)") { |v| @parsed_options[:redirect] = v }
+        opts.on('-e', '--environment ENVIRONMENT', "Totem environment") { |v| Totem.env = v }
+        opts.on('-i', '--instance INSTANCE', "Totem instance") { |v| Totem.instance = v }
+        opts.on(nil,  '--timeout SECONDS', "seconds to wait before force stopping the service (default: 60)") { |v| @parsed_options[:stop_timeout] = v }
+        opts.on(nil,  '--ruby opts', "daemonized ruby interpreter specifc options") { |v| RaadTotem.ruby_options = v }
+
+        opts.on('-h', '--help', 'display help message') { show_options(options_parser) }
+      end
+
+      options_parser
+    end
+
+    # Output the servers options and exit Ruby
+    #
+    # @param opts [OptionsParser] The options parser
+    def show_options(opts)
+      puts(opts)
+      exit!(false)
+    end
+
+  end
+end

data/lib/raad_totem/shell_cmds/service.rb

@@ -0,0 +1,43 @@
+module RaadTotem
+  module ShellCmds
+    class Service < Totem::ShellCmds::Base
+      def run
+        case @args[0]
+        when 'new' then new_s(@args[1])
+        else
+          puts_usage
+        end
+      end
+
+      def new_s(service)
+        return false unless require_arg(service, :service)
+      end
+
+      private
+
+      def puts_usage
+        puts "Usage:\n  bundle exec totem service <command>"
+        puts
+        puts "Commands:\n"
+        puts "  new <service>   - Create a new service."
+      end
+
+      def puts_error(message)
+          puts "ERROR: #{message}"
+          puts
+          puts_usage
+      end
+
+      def require_arg(val, name)
+        if val.nil? || val.length == 0
+          puts_error("You must provide a #{name}.")
+          return false
+        end
+
+        return true
+      end
+    end
+  end
+end
+
+Totem::Shell.register_cmd(:service, RaadTotem::ShellCmds::Service)

data/lib/raad_totem/signal_trampoline.rb

@@ -0,0 +1,39 @@
+require 'thread'
+
+module SignalTrampoline
+
+  module_function
+
+  SIGNALS = {
+    :EXIT => 0, :HUP => 1, :INT => 2, :QUIT => 3, :ILL => 4, :TRAP => 5, :IOT => 6, :ABRT => 6, :FPE => 8, :KILL => 9,
+    :BUS => 7, :SEGV => 11, :SYS => 31, :PIPE => 13, :ALRM => 14, :TERM => 15, :URG => 23, :STOP => 19, :TSTP => 20, 
+    :CONT => 18, :CHLD => 17, :CLD => 17, :TTIN => 21, :TTOU => 22, :IO => 29, :XCPU => 24, :XFSZ => 25, :VTALRM => 26, 
+    :PROF => 27, :WINCH => 28, :USR1 => 10, :USR2 => 12, :PWR => 30, :POLL => 29
+  }
+
+  @signal_q = Queue.new
+  @handlers = {}
+  @handler_thread = nil
+
+  # using threads to bounce signal using a thread-safe queue seem the most robust way to handle signals.
+  # it minimizes the code in the trap block and reissue the signal and its handling in the normal Ruby
+  # flow, within normal threads. 
+
+  def trap(signal, &block)
+    raise("unknown signal") unless SIGNALS.has_key?(signal)
+    @handler_thread ||= detach_handler_thread
+    @handlers[signal] = block
+    Kernel.trap(signal) {Thread.new{@signal_q << signal}}
+  end
+
+  def detach_handler_thread
+    Thread.new do
+      Thread.current.abort_on_exception = true
+      loop do
+        s = @signal_q.pop
+        @handlers[s].call if @handlers[s]
+      end
+    end
+  end
+
+end

data/lib/raad_totem/spoon.rb

@@ -0,0 +1,46 @@
+require 'ffi'
+
+# spoon code taken from Charles Oliver Nutter's spoon gem https://github.com/headius/spoon
+# also see http://blog.headius.com/2009/05/fork-and-exec-on-jvm-jruby-to-rescue.html
+
+module Spoon
+  extend FFI::Library
+  ffi_lib 'c'
+  
+  # int
+  # posix_spawn(pid_t *restrict pid, const char *restrict path,
+  #     const posix_spawn_file_actions_t *file_actions,
+  #     const posix_spawnattr_t *restrict attrp, char *const argv[restrict],
+  #     char *const envp[restrict]);
+  
+  attach_function :_posix_spawn, :posix_spawn, [:pointer, :string, :pointer, :pointer, :pointer, :pointer], :int
+  attach_function :_posix_spawnp, :posix_spawnp, [:pointer, :string, :pointer, :pointer, :pointer, :pointer], :int
+  
+  def self.spawn(*args)
+    spawn_args = _prepare_spawn_args(args)
+    _posix_spawn(*spawn_args)
+    spawn_args[0].read_int
+  end
+
+  def self.spawnp(*args)
+    spawn_args = _prepare_spawn_args(args)
+    _posix_spawnp(*spawn_args)
+    spawn_args[0].read_int
+  end
+  
+  private
+  
+  def self._prepare_spawn_args(args)
+    pid_ptr = FFI::MemoryPointer.new(:pid_t, 1)
+
+    args_ary = FFI::MemoryPointer.new(:pointer, args.length + 1)
+    str_ptrs = args.map {|str| FFI::MemoryPointer.from_string(str)}
+    args_ary.put_array_of_pointer(0, str_ptrs)
+
+    env_ary = FFI::MemoryPointer.new(:pointer, ENV.length + 1)
+    env_ptrs = ENV.map {|key,value| FFI::MemoryPointer.from_string("#{key}=#{value}")}
+    env_ary.put_array_of_pointer(0, env_ptrs)
+    
+    [pid_ptr, args[0], nil, nil, args_ary, env_ary]
+  end
+end

data/lib/raad_totem/unix_daemon.rb

@@ -0,0 +1,131 @@
+require 'etc'
+require 'timeout'
+
+require 'raad/spoon' if RaadTotem.jruby?
+
+module Process
+
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::EPERM
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  module_function :running?
+end
+
+# Raised when the pid file already exist starting as a daemon.
+class PidFileExist < RuntimeError; end
+
+# module Daemonizable requires that the including class defines the @pid_file instance variable
+module Daemonizable
+
+  def pid
+    File.exist?(@pid_file) ? open(@pid_file).read.to_i : nil
+  end
+
+  def daemonize(argv, name, stdout_file = nil)
+    remove_stale_pid_file
+    pwd = Dir.pwd
+
+    if RaadTotem.jruby?
+      # in jruby the process is to posix-spawn a new process and re execute ourself using Spoon.
+      # swap command 'start' for 'post_fork' to signal the second exec
+      spanw_options = [RaadTotem.ruby_path].concat(RaadTotem.ruby_options)
+      spanw_options << $0
+      spanw_options.concat(argv.map{|arg| arg == 'start' ? 'post_fork' : arg})
+      Spoon.spawnp(*spanw_options)
+    else
+      # do the double fork dance
+      Process.fork do
+        Process.setsid
+        exit if fork # exit parent
+
+        Dir.chdir(pwd)
+        post_fork_setup(name, stdout_file)
+
+        yield
+      end
+    end
+  end
+
+  def post_fork_setup(name, stdout_file = nil)
+    $0 = name # set process name, does not work with jruby
+
+    File.umask(0000) # file mode creation mask to 000 to allow creation of files with any required permission late
+    write_pid_file
+
+    # redirect stdin, stdout, stderr
+    STDIN.reopen('/dev/null')
+    stdout_file ? STDOUT.reopen(stdout_file, "a") : STDOUT.reopen('/dev/null', 'a')
+    STDERR.reopen(STDOUT)
+
+    at_exit do
+      remove_pid_file
+    end
+  end
+
+  def send_signal(signal, timeout = 60)
+    if pid = read_pid_file
+      puts(">> sending #{signal} signal to process #{pid}")
+      Process.kill(signal, pid)
+      Timeout.timeout(timeout) do
+        sleep 0.1 while Process.running?(pid)
+      end
+      true
+    else
+      puts(">> can't stop process, no pid found in #{@pid_file}")
+      false
+    end
+  rescue Timeout::Error
+    force_kill_and_remove_pid_file(pid)
+  rescue Interrupt
+    force_kill_and_remove_pid_file(pid)
+  rescue Errno::ESRCH # No such process
+    puts(">> can't stop process, no such process #{pid}")
+    remove_pid_file
+    false
+  end
+
+  def force_kill_and_remove_pid_file(pid)
+    puts(">> sending KILL signal to process #{pid}")
+    Process.kill("KILL", pid)
+    remove_pid_file
+    true
+  rescue Errno::ESRCH # No such process
+    puts(">> can't send KILL, no such process #{pid}")
+    remove_pid_file
+    false
+  end
+
+  def read_pid_file
+    if File.file?(@pid_file) && pid = File.read(@pid_file)
+      pid.to_i
+    else
+      nil
+    end
+  end
+
+  def remove_pid_file
+    File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+  end
+
+  def write_pid_file
+    open(@pid_file,"w") { |f| f.write(Process.pid) }
+    File.chmod(0644, @pid_file)
+  end
+
+  def remove_stale_pid_file
+    if File.exist?(@pid_file)
+      if pid && Process.running?(pid)
+        raise PidFileExist, "#{@pid_file} exists and process #{pid} is runnig. stop the process or delete #{@pid_file}"
+      else
+        puts(">> deleting stale pid file #{@pid_file}")
+        remove_pid_file
+      end
+    end
+  end
+
+end

data/lib/raad_totem/version.rb

@@ -0,0 +1,3 @@
+module RaadTotem
+  VERSION = '0.0.2'
+end unless defined?(RaadTotem::VERSION)

data/lib/raad_totem.rb

@@ -0,0 +1,9 @@
+require 'totem'
+
+require 'raad_totem/version'
+require 'raad_totem/env'
+require 'raad_totem/unix_daemon'
+require 'raad_totem/signal_trampoline'
+require 'raad_totem/runner'
+require 'raad_totem/bootstrap'
+require 'raad_totem/shell_cmds/service'

data/raad.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'raad_totem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'raad_totem'
+  spec.version       = RaadTotem::VERSION
+  spec.authors       = ['Colin Surprenant', 'Chad Remesch']
+  spec.email         = ['colin.surprenant@gmail.com', 'chad@remesch.com']
+  spec.summary       = %q{Easily create daemons in Totem projects (fork of Raad gem)}
+  spec.description   = %q{Easily create daemons in Totem projects (fork of Raad gem)}
+  spec.homepage      = 'https://github.com/chadrem/raad_totem'
+  spec.license       = 'Apache'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency('totem', '>= 0.0.7')
+
+  spec.add_development_dependency('bundler', '~> 1.5')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency "rspec", ['~> 2.8.0']
+end

data/spec/raad_totem/unit/bootstrap_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+# @TODO workaround to bug with Kernel.caller between 1.8 and 1.9 need to dig in this.
+$RAAD_TOTEM_NOT_RUN=true
+require 'raad_totem/bootstrap'
+
+describe RaadTotem::Bootstrap do
+  it "should work" do
+    true.should be_true
+  end
+end

data/spec/raad_totem/unit/env_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'raad_totem/env'
+
+describe "RaadTotem env" do
+  it "should test for jruby" do
+    [true, false].should include(RaadTotem.jruby?)
+  end
+
+  it "should report ruby path" do
+    File.exist?(RaadTotem.ruby_path).should be_true
+  end
+
+  it "should default to empty ruby_options" do
+    RaadTotem.ruby_options.should == []
+  end
+
+  it "should set ruby_options" do
+    RaadTotem.ruby_options = "a b"
+    RaadTotem.ruby_options.should == ['a', 'b']
+  end
+end

data/spec/raad_totem/unit/signal_trampoline_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'raad_totem/signal_trampoline'
+require 'thread'
+require 'timeout'
+
+describe SignalTrampoline do
+  it "should trap signal" do
+    t = Thread.new{Thread.stop}
+    SignalTrampoline.trap(:USR2) {t.run}
+    t.alive?.should be_true
+    Timeout.timeout(5) {sleep(0.1) while !t.stop?} # avoid race condition
+    t.stop?.should be_true
+    Process.kill(:USR2, Process.pid)
+    Timeout.timeout(5) {sleep(0.1) while t.alive?}
+    t.alive?.should be_false
+    t.join(5).should == t
+  end
+
+  it "should raise on bad signal" do
+    lambda{SignalTrampoline.trap(:WAGADOUDOU) {}}.should raise_exception
+  end
+end

data/spec/raad_totem/unit/spoon_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'raad_totem/env'
+require 'raad_totem/spoon' if RaadTotem.jruby?
+
+if RaadTotem.jruby?
+
+  describe Spoon do
+    it "should work" do
+      true.should be_true
+    end
+  end
+
+end

data/spec/raad_totem/unit/unix_daemon_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+require 'raad_totem/env'
+require 'raad_totem/unix_daemon'
+require 'timeout'
+
+class TestService
+  include Daemonizable
+
+  attr_accessor :pid_file
+
+  def initialize(pid_file)
+    @pid_file = pid_file
+  end
+end
+
+module Spoon
+end unless RaadTotem.jruby?
+
+describe 'UnixDaemon' do
+
+  before :all do
+    @l = 'test.log'
+    @p = 'test.pid'
+    File.delete(@l) if File.exist?(@l)
+    File.delete(@p) if File.exist?(@p)
+  end
+
+  before :each do
+    File.delete(@l) if File.exist?(@l) rescue nil
+    File.delete(@p) if File.exist?(@p) rescue nil
+    @service = TestService.new(@p)
+  end
+
+  describe "non jruby daemonize" do
+
+    it 'should create a pid file' do
+      @service.should_receive(:remove_stale_pid_file).once
+      @service.daemonize([], 'test') do
+        Thread.new{Thread.stop}.join(5)
+      end
+
+      Timeout.timeout(5) do
+        while !File.exist?(@service.pid_file); sleep(0.1); end
+        true
+      end.should == true
+
+      (pid = @service.pid).should > 0
+      Process.kill(:TERM, pid)
+    end
+
+    it 'should redirect stdio to a log file' do
+      @service.daemonize([], 'test', @l) do
+        puts("puts"); STDOUT.flush
+        STDERR.puts("STDERR.puts"); STDERR.flush
+        STDOUT.puts("STDOUT.puts"); STDOUT.flush
+      end
+
+      Timeout.timeout(5) do
+        while !File.exist?(@l); sleep(0.1); end
+        true
+      end.should == true
+
+      f = File.new(@l, "r")
+      Timeout.timeout(5) do
+        while (l = f.readlines) != ["puts\n", "STDERR.puts\n", "STDOUT.puts\n"]; sleep(0.1); f.rewind; end
+        true
+      end.should == true
+    end
+  end unless RaadTotem.jruby?
+
+  describe "jruby daemonize (from any ruby)" do
+
+    # we don't have to use jruby for this test, Spoon is mocked when not jruby.
+
+    it "should swap start for post_fork and call spawnp with args" do
+      @service.should_receive(:remove_stale_pid_file).once
+      RaadTotem.should_receive(:jruby?).and_return(true)
+      Spoon.should_receive(:spawnp).with(RaadTotem.ruby_path, "-JXmx=256m", $0, "test", "post_fork")
+
+      RaadTotem.ruby_options = "-JXmx=256m"
+      @service.daemonize(["test", "start"], 'test')
+      RaadTotem.ruby_options = ""
+    end
+  end
+
+  describe "jruby daemonize (only in jruby)" do
+
+    it "should daemonize" do
+      false.should == false
+    end
+  end if RaadTotem.jruby?
+
+  describe "post_fork_setup" do
+
+    it 'should create a pid file' do
+      STDIN.should_receive(:reopen)
+      STDOUT.should_receive(:reopen)
+      STDERR.should_receive(:reopen)
+      @service.post_fork_setup('test', nil)
+      File.exist?(@service.pid_file).should be_true
+      @service.pid.should == Process.pid
+    end
+
+    it 'should redirect stdio to a log file' do
+      @service = TestService.new(@p)
+
+      STDIN.should_receive(:reopen).with("/dev/null")
+      STDOUT.should_receive(:reopen).with(@l, 'a')
+      STDERR.should_receive(:reopen).with(STDOUT)
+
+      @service.post_fork_setup('test', @l)
+    end
+  end
+
+  describe 'read/write/remove pid file' do
+
+    it 'should write pid file' do
+      @service.write_pid_file
+      File.exist?(@service.pid_file).should be_true
+      File.read(@p).to_i.should == Process.pid
+    end
+
+    it 'should read pid file' do
+      @service.write_pid_file
+      @service.read_pid_file.should == Process.pid
+    end
+
+    it 'should remove pid file' do
+      @service.write_pid_file
+      File.exist?(@service.pid_file).should be_true
+      @service.remove_pid_file
+      File.exist?(@service.pid_file).should be_false
+    end
+  end
+
+  describe 'send_signal' do
+
+    it 'should send signal and terminate process' do
+      @service.write_pid_file
+      t = Thread.new{Thread.stop}
+      Kernel.trap(:USR2) {Thread.new{t.run}}
+      Process.should_receive(:running?).once.and_return(false)
+      $stdout.should_receive(:write).twice # mute trace
+      @service.send_signal(:USR2, 5).should be_true
+      Timeout.timeout(5) {t.join}
+    end
+
+    it 'should force kill on Timeout::Error exception' do
+      @service.write_pid_file
+      Process.should_receive(:kill).and_raise(Timeout::Error)
+      @service.should_receive(:force_kill_and_remove_pid_file).and_return(true)
+      $stdout.should_receive(:write).twice # mute trace
+      @service.send_signal(:USR2, 5).should be_true
+    end
+
+    it 'should force kill on Interrupt exception' do
+      @service.write_pid_file
+      Process.should_receive(:kill).and_raise(Interrupt)
+      @service.should_receive(:force_kill_and_remove_pid_file).and_return(true)
+      $stdout.should_receive(:write).twice # mute trace
+      @service.send_signal(:USR2, 5).should be_true
+    end
+
+    it 'should remove pid file on Errno::ESRCH exception' do
+      @service.write_pid_file
+      Process.should_receive(:kill).and_raise(Errno::ESRCH)
+      $stdout.should_receive(:write).exactly(4).times # mute trace
+      @service.should_receive(:remove_pid_file)
+      @service.send_signal(:USR2, 5).should be_false
+    end
+  end
+
+  def force_kill_and_remove_pid_file(pid)
+    puts(">> sending KILL signal to process #{pid}")
+    Process.kill("KILL", pid)
+    remove_pid_file
+    true
+  rescue Errno::ESRCH # No such process
+    puts(">> can't send KILL, no such process #{pid}")
+    remove_pid_file
+    false
+  end
+
+  describe 'force_kill_and_remove_pid_file' do
+
+    it 'should send KILL signal and terminate process' do
+      @service.write_pid_file
+      Process.should_receive(:kill).with("KILL", 666).once
+      $stdout.should_receive(:write).twice # mute trace
+      @service.force_kill_and_remove_pid_file(666).should be_true
+    end
+
+    it 'should remove pid file on no such process exception' do
+      @service.write_pid_file
+      $stdout.should_receive(:write).exactly(4).times # mute trace
+      Process.should_receive(:kill).with("KILL", 666).once.and_raise(Errno::ESRCH)
+      @service.should_receive(:remove_pid_file)
+      @service.force_kill_and_remove_pid_file(666).should be_false
+    end
+  end
+end

data/spec/raad_totem/unit/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'raad_totem/version'
+
+describe "RaadTotem VERSION" do
+  it "should work" do
+    true.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift File.dirname(__FILE__) + '/../lib/'
+$:.unshift File.dirname(__FILE__) + '/../spec'
+
+require 'rspec'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: raad_totem
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Colin Surprenant
+- Chad Remesch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: totem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+description: Easily create daemons in Totem projects (fork of Raad gem)
+email:
+- colin.surprenant@gmail.com
+- chad@remesch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/raad_totem.rb
+- lib/raad_totem/bootstrap.rb
+- lib/raad_totem/env.rb
+- lib/raad_totem/runner.rb
+- lib/raad_totem/shell_cmds/service.rb
+- lib/raad_totem/signal_trampoline.rb
+- lib/raad_totem/spoon.rb
+- lib/raad_totem/unix_daemon.rb
+- lib/raad_totem/version.rb
+- raad.gemspec
+- spec/raad_totem/unit/bootstrap_spec.rb
+- spec/raad_totem/unit/env_spec.rb
+- spec/raad_totem/unit/signal_trampoline_spec.rb
+- spec/raad_totem/unit/spoon_spec.rb
+- spec/raad_totem/unit/unix_daemon_spec.rb
+- spec/raad_totem/unit/version_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/chadrem/raad_totem
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Easily create daemons in Totem projects (fork of Raad gem)
+test_files:
+- spec/raad_totem/unit/bootstrap_spec.rb
+- spec/raad_totem/unit/env_spec.rb
+- spec/raad_totem/unit/signal_trampoline_spec.rb
+- spec/raad_totem/unit/spoon_spec.rb
+- spec/raad_totem/unit/unix_daemon_spec.rb
+- spec/raad_totem/unit/version_spec.rb
+- spec/spec_helper.rb