rinit 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea0acfa0eb74979cb10df4d21486576f600304e2
+  data.tar.gz: 5b130fbf83ac7b8b82955c6be348a86a6a88d36c
+SHA512:
+  metadata.gz: 389a152befef38018ca332c82fbbcc8527febaada6fc4c84784a889e989f46f2f2df0ea00d98de0a5be321498922a3a18e7b93d5b51f8d8d308b4b4981bc7e1d
+  data.tar.gz: 571ba2186bab9183b14cb484ca549de3e3d2b746d083e389328a5d4828cd5dfaed089fc3db0674e3aece20ef3e0872de4c7cd6b4c5324be9de136468432abca8

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/foo_daemon.rb
+test/test_init.rb
+test/version_tmp
+tmp
+tags

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 YOUR NAME
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brad Smith
+
+MIT License
+
+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.md

@@ -0,0 +1,120 @@
+# Rinit
+
+Rinit is a `init-like` script witten in ruby.  
+
+### This only works for Debian based systems currently.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rinit'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rinit
+
+## Usage
+
+Let's say you have a daemon script called `foodaemon.rb`.  
+You want to be able to `start, stop, restart, and get the status` of said daemon.  
+Better yet, you need a pid file so you can use monit to monitor the process.  
+Create a file in `/etc/init.d/` (or where ever you like).  Name it what you want and make sure it is executable.
+
+### your awesome damon script
+```ruby
+loop do
+  puts "I am a daemon...and I loop loop loop and I loop loop loop!"
+  sleep 10
+end
+```
+
+### a init script to control said awesomeness
+
+```ruby
+#!/usr/bin/env ruby
+require 'rinit'
+
+extend Rinit
+# app_name      This is a startup script for use in /etc/init.d
+#
+# description:  This will start, stop, and restart foo daemon
+
+# this is an example of using ruby for a init script
+
+APP_NAME = "foodaemon"
+PIDFILE = "/tmp/#{APP_NAME}.pid"
+PATH = "/home/bradleyd/Projects/rinit/test/"
+DAEMON = "#{PATH}/foo_daemon.rb"
+USER = ENV["USER"]
+
+case ARGV.first
+when 'status'
+  puts "#{APP_NAME} is #{Rinit.status(PIDFILE)}"
+when 'start'
+  result = Rinit.start :cmd => "#{DAEMON}", 
+                       :chuid => USER,
+                       :pidfile => PIDFILE
+
+  puts "#{APP_NAME} is started" unless result.nil?
+when 'stop'
+  Rinit.stop(PIDFILE)
+  puts "#{APP_NAME} is stopped" 
+when 'restart'
+  puts "#{APP_NAME} is restarting..."
+  Rinit.restart(PIDFILE, :cmd => "#{DAEMON}",
+                         :chuid => USER,
+                         :pidfile => PIDFILE)
+end
+
+unless %w{start stop restart status}.include? ARGV.first
+  puts "Usage: #{APP_NAME} {start|stop|restart}"
+  exit
+end
+```
+
+Then you can do this
+
+```bash
+./foo status
+foo is stoppped
+```
+
+```bash
+./foo start
+foo is running
+```
+You get the idea...
+
+### Simple Template Builder
+
+`rinit` also has a simple template builder.  For example,
+to generate a init script to be used in `init.d/` one could do this
+
+* only monit and init templates are supported as of now
+
+```ruby
+    -t, --template type              generator for init template
+    -n, --daemon-name name           name of the dameon
+    -h, --help                       Show this message
+```
+
+```ruby
+rinit -t init -n foobar
+```
+
+This will create a file in the current directory where you ran `rinit`
+
+* your milage may vary
+ 
+## 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,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/bin/rinit

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+require "bundler/setup"
+require 'rinit'
+require 'optparse'
+
+options = {}
+banner = nil
+
+# set the default option is none are given
+#
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  opts.on("-t ", "--template type", "generator for init template") do |t|
+    options[:template] = t
+  end
+
+  opts.on("-n ", "--daemon-name name", "name of the dameon") do |n|
+    options[:name] = n
+  end
+
+
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  #set current options
+  banner = opts
+
+end.parse!
+
+if options.empty?
+  puts banner
+  exit
+end
+
+template = Rinit::TemplateBuilder.new(options)
+template.build

data/examples/init

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'rinit'
+
+extend Rinit
+
+# app_name      This is a startup script for use in /etc/init.d
+#
+# description:  This will start, stop, and restart <%= @name %>
+
+# this is an example of using ruby for a init script
+
+APP_NAME = <%= @name %>
+PIDFILE = "/tmp/#{APP_NAME}.pid"
+# change PATH to point at your daemon path
+PATH = File.expand_path File.dirname(__FILE__)
+DAEMON = File.join(PATH, <%= @name %>)
+# @todo change this to the user you want the daemon to run as
+USER = ENV["USER"]
+
+case ARGV.first
+when "status"
+  puts "#{APP_NAME} is #{Rinit.status(PIDFILE) ? "running" : "stopped"}"
+when "start"
+  result = Rinit.start(cmd: DAEMON, 
+                       chuid: USER,
+                       pidfile: PIDFILE)
+ 
+  puts "#{APP_NAME} has started" unless result.nil?
+when "stop"
+  Rinit.stop(PIDFILE)
+  puts "#{APP_NAME} is stopped"
+when "restart"
+  puts "#{APP_NAME} is restarting..."
+  Rinit.restart(PIDFILE, cmd: DAEMON,
+                         chuid: USER,
+                         pidfile: PIDFILE)
+end
+
+unless %w{start stop restart status}.include? ARGV.first
+  puts "Usage: #{APP_NAME} {start|stop|restart}"
+  exit
+end

data/examples/monit

@@ -0,0 +1,8 @@
+check process <%= @name %>
+   with pidfile /var/run/<%= @name %>.pid
+   start program = "/etc/init.d/<%= @name %> start"
+   stop program = "/etc/init.d/<%= @name %> stop"
+   if cpu > 60% for 2 cycles then alert
+   if failed host 127.0.0.1 port 3000 protocol http
+       then alert
+

data/lib/rinit.rb

@@ -0,0 +1,8 @@
+require "rinit/version"
+require "rinit/exceptions"
+require "rinit/process_utils"
+require "rinit/commands"
+require "rinit/template_builder"
+
+module Rinit
+end

data/lib/rinit/commands.rb

@@ -0,0 +1,41 @@
+require "open4"
+module Rinit
+  class << self
+    include ProcessUtils
+
+    # @param  opts [Hash] opts :cmd, :chuid, :pidfile
+    # @return [nil]
+    # @example
+    #   {cmd: "/tmp/foo_daemon.rb", chuid: "foo", pidfile: "/tmp/foo.pid"}
+    #
+    def start(opts={})
+      command = opts.fetch(:cmd) { raise Rinit::CommandException.new "No command given" }
+      user    = opts.fetch(:chuid) { raise Rinit::CommandException.new "No user given" }
+      pidfile = opts.fetch(:pidfile) { raise Rinit::CommandException.new "No pidfile was given" }
+      may_the_fork_be_with_you(command, pidfile)
+    end
+
+    # @param pidfile [String] the full pidfile path
+    # @return [nil] if there were not any errors
+    def stop(pidfile)
+      kill_process(pidfile)
+      pidfile_cleanup(pidfile)
+    end
+
+    # @param pidfile [String] the full pidfile path
+    # @return process_status [String] Started or Stopped
+    def status pidfile
+      is_process_running?(pidfile)
+    end
+
+    # @param pidfile [String] the full pidfile path
+    # @param opts [Hash] see #start
+    # @return process_status [String] Started or Stopped
+    # @example
+    #   "/tmp/foo.pid", {cmd: "/tmp/foo_daemon.rb", chuid: "foo", pidfile: "/tmp/foo.pid"}
+    def restart(pidfile, opts={})
+      stop(pidfile)
+      start(opts)
+    end
+  end
+end

data/lib/rinit/exceptions.rb

@@ -0,0 +1,4 @@
+module Rinit
+  class CommandException < StandardError; end
+  class ProcessException < StandardError; end
+end

data/lib/rinit/process_utils.rb

@@ -0,0 +1,80 @@
+require "sys/proctable"
+require "fileutils"
+
+module Rinit
+  module ProcessUtils
+    include Sys
+
+    # @private
+    def may_the_fork_be_with_you(command, pidfile)
+      rd, wr = IO.pipe
+      pid = fork do
+        rd.close
+        begin
+          exec(command)
+        rescue SystemCallError
+          wr.write('!')
+          exit 1
+        end
+      end
+      wr.close
+      command_result = if rd.eof?
+                         write_pidfile(pid, pidfile)
+                       else
+                         nil
+                       end
+    end
+
+    # @private 
+    def get_pid_from_file(filename)
+      begin
+        pid = IO.readlines(filename)
+      rescue Errno::ENOENT => e
+        puts e.message + "---Are you sure it is running?"
+        exit 1
+      end
+      # if the file is there but no pid was written to_i returns 0
+      pid.empty? ? -1 : pid[0].to_i
+    end
+
+    # @private
+    def is_process_running?(pidfile)
+      pid = get_pid_from_file(pidfile)
+      ProcTable.ps{ |process|
+       return true if process.pid == pid
+      }
+      false
+    end
+
+    # @private 
+    def pidfile_cleanup pidfile
+      begin
+        FileUtils.rm(pidfile)
+      rescue Errno::ENOENT => e
+        puts e.message
+        exit 1
+      end
+    end  
+    
+    # @private 
+    def kill_process(pidfile)
+      pid = get_pid_from_file(pidfile)
+      # should never be negative unless there is an issue with writing the pid
+      return if pid < 0
+      begin
+        Process.kill(9,pid)
+      rescue Errno::ESRCH => e
+        puts e.message
+        puts "The pid file may not have been cleaned up properly."
+        exit 1
+      end
+    end
+   
+    # @private 
+    def write_pidfile(pid, pidfile)
+      File.open(pidfile, 'w') { |f| f.write(pid) }
+    end
+
+  end
+  
+end

data/lib/rinit/template_builder.rb

@@ -0,0 +1,38 @@
+require "erb"
+module Rinit
+  # simple template generator 
+  #
+  # @note only supports init and monit right now
+  class TemplateBuilder
+
+    def initialize(opts={})
+      @template = opts.fetch(:template) { 'init' }
+      @name = opts.fetch(:name) { 'foobar' }
+    end
+
+    # @params nil [nil]
+    # @return  [nil]
+    def build
+      @erb_temp = ERB.new(File.read(template_file)) #.result(binding)
+      write_out_file
+    end
+
+    private
+    # @private
+    def write_out_file 
+      File.open(example_name, 'w') do |f|
+        f.write @erb_temp.result(binding)
+      end
+    end
+    
+    # @private
+    def example_name
+      "#{@name}.#{@template}"
+    end
+
+    # @private
+    def template_file
+      File.join(File.expand_path(File.dirname(__FILE__)), "../../", "examples", @template)
+    end
+  end
+end

data/lib/rinit/version.rb

@@ -0,0 +1,3 @@
+module Rinit
+  VERSION = "0.1.5"
+end

data/rinit.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rinit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rinit"
+  spec.version       = Rinit::VERSION
+  spec.authors       = ["Bradley Smith"]
+  spec.email         = ["bradleydsmith@gmail.com"]
+  spec.description   = %q{ Provides init-like script structure for ruby}
+  spec.summary       = %q{ Provides init-like script structure for ruby so you can control your daemons. }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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 "sys-proctable"
+  spec.add_dependency "open4"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "minitest"
+end

data/test/rinit_commands_test.rb

@@ -0,0 +1,52 @@
+require_relative "test_helper"
+require 'tempfile'
+require 'sys/proctable'
+require "ostruct"
+
+class RinitCommandsTest < MiniTest::Unit::TestCase
+  extend Rinit
+  include Sys
+
+  DAEMON = File.join(File.expand_path(File.dirname(__FILE__)), "support", "foo_daemon.rb")
+  USER   = ENV["USER"]
+
+  def setup
+    @rinit = Rinit
+    @pidfile = Tempfile.new("foo.pid")
+    @pidfile.rewind
+  end
+
+  def teardown
+    #@pidfile.unlink
+  end
+
+  def test_that_respond_to_start
+    assert_respond_to @rinit, :start
+  end
+ 
+  def test_that_respond_to_stop
+    assert_respond_to @rinit, :stop
+  end
+
+  def test_that_respond_to_status
+    assert_respond_to @rinit, :status
+  end
+
+  def test_that_respond_to_restart
+    assert_respond_to @rinit, :restart
+  end
+  
+  def test_should_start_daemon_and_stop_daemon
+    assert(@rinit.start(:cmd => DAEMON, 
+                        :chuid => USER, 
+                        :pidfile => @pidfile.path))
+
+    assert(@rinit.status(@pidfile.path))
+    assert(@rinit.stop(@pidfile.path))
+  end
+
+  def test_status_should_be_stopped
+    refute(@rinit.status(@pidfile.path))  
+  end
+
+end

data/test/support/foo_daemon.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+loop do 
+ File.open("/tmp/looper", "a+") { |f| f.write "loop de do!!" }
+ sleep 60
+ exit
+end

data/test/support/sample_init.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require 'rinit'
+
+extend Rinit
+
+# app_name      This is a startup script for use in /etc/init.d
+#
+# description:  This will start, stop, and restart foo daemon
+
+# this is an example of using ruby for a init script
+
+APP_NAME = "Foodaemon"
+PIDFILE = "/tmp/#{APP_NAME}.pid"
+PATH = File.expand_path File.dirname(__FILE__)
+DAEMON = File.join(PATH, "foo_daemon.rb")
+USER = ENV["USER"]
+
+case ARGV.first
+when "status"
+  puts "#{APP_NAME} is #{Rinit.status(PIDFILE) ? "running" : "stopped"}"
+when "start"
+  result = Rinit.start(cmd: DAEMON, 
+                       chuid: USER,
+                       pidfile: PIDFILE)
+ 
+  puts "#{APP_NAME} has started" unless result.nil?
+when "stop"
+  Rinit.stop(PIDFILE)
+  puts "#{APP_NAME} is stopped"
+when "restart"
+  puts "#{APP_NAME} is restarting..."
+  Rinit.restart(PIDFILE, cmd: DAEMON,
+                         chuid: USER,
+                         pidfile: PIDFILE)
+end
+
+unless %w{start stop restart status}.include? ARGV.first
+  puts "Usage: #{APP_NAME} {start|stop|restart}"
+  exit
+end
+

data/test/template_builder_test.rb

@@ -0,0 +1,29 @@
+require_relative "test_helper"
+require_relative './test_helper'
+
+class RinitTemplateBuilderTest < MiniTest::Unit::TestCase
+ 
+  def setup
+    @name = 'foobar'
+    @template = 'init'
+    @example_file = File.join(File.expand_path(File.dirname(__FILE__)), "../", 
+                              "#{@name}.#{@template}")   
+    @generator = Rinit::TemplateBuilder.new(template: @template, name: @name)
+  end
+
+  def test_should_respond_to_build
+    assert_respond_to(@generator, :build)
+  end
+
+  def test_should_create_template
+    @generator.build
+    assert(File.exist?(@example_file), "cant find file")
+  end
+
+  def teardown
+    begin
+      FileUtils.rm(@example_file)
+    rescue
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "minitest/autorun"
+require "minitest/pride"
+require "mocha/setup"
+require "rinit"

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: rinit
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Bradley Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: open4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: mocha
+  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: minitest
+  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'
+description: ' Provides init-like script structure for ruby'
+email:
+- bradleydsmith@gmail.com
+executables:
+- rinit
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- bin/rinit
+- examples/init
+- examples/monit
+- lib/rinit.rb
+- lib/rinit/commands.rb
+- lib/rinit/exceptions.rb
+- lib/rinit/process_utils.rb
+- lib/rinit/template_builder.rb
+- lib/rinit/version.rb
+- rinit.gemspec
+- test/rinit_commands_test.rb
+- test/support/foo_daemon.rb
+- test/support/sample_init.rb
+- test/template_builder_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Provides init-like script structure for ruby so you can control your daemons.
+test_files:
+- test/rinit_commands_test.rb
+- test/support/foo_daemon.rb
+- test/support/sample_init.rb
+- test/template_builder_test.rb
+- test/test_helper.rb