necro 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDcwZDQzZWIxNWM4Y2FhMjVmNzYyODE0MDdhMjk3Nzc1ZjMyNzFmOA==
+  data.tar.gz: !binary |-
+    ZjAyZDg0NmNjMTU0MmQ0Y2NjY2MwMGZjMTE3ZDhhZDQ5NDNlOGI0MA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YmRkZGViN2M5NjYzYTAxYjU2YmIxMGVhYTAyN2VlNDg5MjEwMzBiNGY5NWNl
+    YWRhNDM1YTY4ZDc4OGUyMGVkZWEwMmQ4MjM2M2RhNDc2MmM4OGZmYWEwZGQ2
+    YWVmYjRkNjFhZDgxNDE0NmNjY2I0NjI2YjhhODc3ODBlZDA4Yjk=
+  data.tar.gz: !binary |-
+    YWE4ZjI0NDA2OTg4NTJkNDNkMmU5ZWUwNTg5ZjI3ODMwY2QzMGY3YzM1MmM0
+    OGNiZmE3YTU1NjUxODk2ZGMzNjljOWUwNzhlOWY0YzJhYTM4ZjZjZDM3ZTRh
+    ODg1Mzc2NmI1NGZiMDkzMWE5NzU4YmYwYjRiNzJlMTM5M2EzODM=

data/.gitignore

@@ -0,0 +1,5 @@
+process.yml
+necro.ini
+config/
+*.gem
+

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+script: bundle exec rake spec
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'pry'
+

data/Rakefile

@@ -0,0 +1,5 @@
+desc "Run the tests"
+task :spec do
+  spec_files = Dir["spec/**/*.rb"]
+  sh("bacon -I spec #{spec_files.join(" ")}")
+end

data/bin/necro

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+begin
+  require "necro"
+rescue LoadError
+  necro_lib_path = File.expand_path('../../lib', __FILE__)
+  $:.unshift(necro_lib_path)
+  require "necro"
+end
+
+Necro::Runner.run(ARGV)
+
+

data/lib/necro.rb

@@ -0,0 +1,19 @@
+$: << File.dirname(__FILE__) unless $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Necro
+  VERSION = "0.0.2"
+end
+
+require "colored"
+require_relative "necro/runner"
+require_relative "necro/command_listener"
+require_relative "necro/errors"
+require_relative "necro/config"
+require_relative "necro/commander"
+require_relative "necro/command_worker"
+require_relative "necro/reactor"
+
+
+
+
+

data/lib/necro/command_listener.rb

@@ -0,0 +1,3 @@
+require_relative "command_listener/server"
+require_relative "command_listener/client"
+

data/lib/necro/command_listener/client.rb

@@ -0,0 +1,34 @@
+module Necro
+  module CommandListener
+    class Client
+      attr_accessor :client_socket
+      def initialize(client_socket)
+        @client_socket = client_socket
+      end
+
+      def read_and_execute
+        command_info = client_socket.read()
+        if command_info && !command_info.empty?
+          worker_command, command_label, rest_args = command_info.strip.split(" ")
+          if worker_command && command_label
+            run_command(worker_command, command_label, rest_args)
+          end
+        end
+        client_socket.close()
+      end
+
+      def run_command(worker_command, command_label, rest_args = nil)
+        case worker_command
+        when 'add'
+          Necro::COMMANDER.add_command_by_label(command_label)
+        when 'remove'
+          Necro::COMMANDER.remove_command(command_label, rest_args)
+        when 'reload'
+          Necro::COMMANDER.reload_command(command_label)
+        else
+          $stdout.puts("\n Invalid command".red)
+        end
+      end
+    end
+  end
+end

data/lib/necro/command_listener/server.rb

@@ -0,0 +1,31 @@
+require "fileutils"
+
+module Necro
+  module CommandListener
+    class Server
+      SOCKET_PATH = "/tmp/necro"
+      def initialize
+        @open_clients = []
+        clean_old_socket()
+        UNIXServer.open(SOCKET_PATH) do |client|
+          loop do
+            client_socket = client.accept
+            process_client(client_socket)
+          end
+        end
+      end
+
+      def clean_old_socket
+        if File.exists?(SOCKET_PATH)
+          FileUtils.rm(SOCKET_PATH, :force => true)
+        end
+      end
+
+      def process_client(client_socket)
+        client = Necro::CommandListener::Client.new(client_socket)
+        client.read_and_execute
+      end
+    end
+  end
+
+end

data/lib/necro/command_worker.rb

@@ -0,0 +1,30 @@
+module Necro
+  class CommandWorker
+    attr_accessor :command_label, :pipe_end, :pid, :color
+    
+    def initialize(command_label, pipe_end, pid, color)
+      @command_label = command_label
+      @pipe_end = pipe_end
+      @pid = pid
+      @color = color
+    end
+
+    # Copied verbatim from Eventmachine code
+    def receive_data data
+      (@buf ||= '') << data
+
+      while @buf.slice!(/(.*?)\r?\n/)
+        receive_line($1)
+      end
+    end
+
+    def unbind
+      # $stdout.print(".")
+    end
+
+    # Print the lines received over the network
+    def receive_line(line)
+      $stdout.puts "#{@command_label.send(color)} : #{line}"
+    end
+  end
+end

data/lib/necro/commander.rb

@@ -0,0 +1,157 @@
+require "io/console"
+require 'pty'
+
+module Necro
+  class Commander
+    MAX_PROCESS_COUNT = 10
+    LABEL_COLORS = ['green', 'yellow', 'blue', 'magenta', 'cyan']
+    attr_accessor :reactor, :workers, :thread_group, :open_pipes
+    
+    def initialize
+      # mapping between open pipes and worker classes
+      @open_pipes = {}
+
+      # mapping between command label and worker classes
+      @workers = {}
+      
+      @thread_group = ThreadGroup.new()
+      @worker_mutex = Mutex.new()
+      @reactor = Necro::Reactor.new
+      Thread.abort_on_exception = true
+    end
+
+    def start_manager
+      if !Necro::CONFIG.processes || Necro::CONFIG.processes.empty?
+        raise Necro::Errors::InvalidConfig.new("No processes configured in config file")
+      end
+      unix_server_thread = Thread.new { Necro::CommandListener::Server.new() }
+      thread_group.add(unix_server_thread)
+      Necro::CONFIG.processes.each { |process_info| add_command(process_info) }
+      reactor.start
+    end
+
+    def add_command(process_info)
+      m, s = PTY.open
+      s.raw! # disable newline conversion.
+
+      pid = run_command(process_info, s)
+
+      s.close()
+
+      selected_color = LABEL_COLORS.shift()
+      LABEL_COLORS.push(selected_color)
+      worker = Necro::CommandWorker.new(process_info.label, m, pid, selected_color)
+
+      add_worker(worker)
+      wait_on_pid(process_info.label,pid)
+    end
+
+    def add_command_by_label(command_label)
+      process_info = Necro::CONFIG.processes.detect {|pconfig|
+        pconfig.label == command_label
+      }
+      if process_info
+        add_command(process_info)
+      end
+    end
+
+    def reload_command(command_label)
+      remove_command(command_label)
+      add_command_by_label(command_label)
+    end
+
+    def remove_command(command_label, rest_args)
+      worker = workers[command_label]
+      signal_to_use = rest_args ? Array(rest_args).first : 'INT'
+
+      if worker
+        $stdout.puts("Removing #{command_label} with signal #{signal_to_use}".red)
+        process_kill(worker.pid, signal_to_use)
+      end
+    end
+
+    def get_worker_from_fd(fd)
+      open_pipes[fd.fileno]
+    end
+
+    def get_worker_from_label(label)
+      workers[label]
+    end
+    
+    private
+    def process_kill(pid, signal_to_use)
+      if signal_to_use.to_i == 0
+        Process.kill(signal_to_use, pid)
+      else
+        Process.kill(signal_to_use.to_i, pid)
+      end
+    end
+    
+    # Remove worker from all collections
+    def remove_worker(command_label)
+      @worker_mutex.synchronize do
+        worker = @workers[command_label]
+        if worker
+          @open_pipes.delete(worker.pipe_end.fileno)
+          @reactor.remove_from_monitoring(worker.pipe_end)
+          @workers.delete(command_label)
+        end
+      end
+    end
+
+    # add worker to global collections
+    def add_worker(worker)
+      @worker_mutex.synchronize do
+        @open_pipes[worker.pipe_end.fileno] = worker
+        @workers[worker.command_label] = worker
+        @reactor.add_to_monitor(worker.pipe_end)
+      end
+    end
+
+    def run_command(process_info, write_pipe)
+      if defined?(Bundler)
+        Bundler.with_clean_env do
+          spawn(process_info.cmd, 
+            :chdir => process_info.dir || "/", :out => write_pipe, :err => write_pipe
+          )
+        end
+      else
+        spawn(process_info.cmd, 
+          :chdir => process_info.dir || "/", :out => write_pipe, :err => write_pipe
+        )
+      end
+    end
+
+    def wait_on_pid(command_label,pid)
+      raise Necro::Errors::ToomanyOpenConnections if @thread_group.enclosed?
+      thread = Thread.new do
+        Process.wait(pid)
+        message = "Process with command #{command_label} exited with status #{$?.exitstatus}"
+        $stdout.puts("\n#{message}".red)
+        notify_user(message)
+        remove_worker(command_label)
+      end
+      @thread_group.add(thread)
+    end
+
+    def notify_user(message)
+      if defined?(Bundler)
+        Bundler.with_clean_env do
+          check_and_notify_with_terminal_notifier(message)
+        end
+      else
+        check_and_notify_with_terminal_notifier(message)
+      end
+    end
+
+    def check_and_notify_with_terminal_notifier(message)
+      return unless RUBY_PLATFORM.downcase.include?("darwin")
+
+      command_path = `which terminal-notifier`
+      if command_path && !command_path.empty?
+        system("terminal-notifier -message '#{message}' -title Necro")
+      end
+    end
+
+  end
+end

data/lib/necro/config.rb

@@ -0,0 +1,19 @@
+require "yaml"
+require 'iniparse'
+
+module Necro
+  class Config
+    attr_accessor :processes
+    def initialize(filename)
+      @ini_content = File.read(filename)
+      @processes = process_ini(@ini_content)
+    end
+
+    def process_ini(ini_content)
+      document = IniParse.parse(ini_content)
+      document.map do |section|
+        OpenStruct.new(label: section.key, dir: section["directory"], cmd: section["command"])
+      end
+    end
+  end
+end

data/lib/necro/errors.rb

@@ -0,0 +1,14 @@
+module Necro
+  module Errors
+    class ToomanyOpenConnections < StandardError; end
+    class ProcessTerminated < StandardError
+      attr_accessor :message, :ready_fd
+      def initialize(ready_fd, message)
+        @ready_fd = ready_fd
+        @message = message
+      end
+    end
+
+    class InvalidConfig < StandardError; end
+  end
+end

data/lib/necro/reactor.rb

@@ -0,0 +1,61 @@
+module Necro
+  class Reactor
+    attr_accessor :monitored_fds
+    def initialize
+      @monitored_fds = []
+    end
+
+    def add_to_monitor(fd)
+      @monitored_fds << fd
+    end
+
+    def remove_from_monitoring(fd)
+      @monitored_fds.delete(fd)
+    end
+
+    def start
+      loop do
+        watch_on_pipe
+      end
+    end
+
+    def watch_on_pipe
+      ready_read_fds,ready_write_fds,read_error_fds = select(monitored_fds,[],[],0.05)
+
+      if ready_read_fds && !ready_read_fds.empty?
+        handle_read_event(ready_read_fds)
+      end
+    end
+
+    def handle_read_event(ready_read_fds)
+      ready_fds = ready_read_fds.flatten.compact
+      ready_fds.each {|ready_fd| process_read(ready_fd) }
+    end
+
+    def process_read(ready_fd)
+      command_worker = Necro::COMMANDER.get_worker_from_fd(ready_fd)
+      begin
+        data = read_data(ready_fd)
+        command_worker.receive_data(data)
+      rescue Necro::Errors::ProcessTerminated
+        command_worker.unbind()
+      end
+    end
+
+    def read_data(ready_fd)
+      sock_data = []
+      begin
+        while(t_data = ready_fd.read_nonblock(64))
+          sock_data << t_data
+        end
+      rescue Errno::EAGAIN
+        return sock_data.join
+      rescue Errno::EWOULDBLOCK
+        return sock_data.join
+      rescue
+        raise Necro::Errors::ProcessTerminated.new(ready_fd,sock_data.join)
+      end
+    end
+
+  end
+end

data/lib/necro/runner.rb

@@ -0,0 +1,101 @@
+require "slop"
+require "ostruct"
+require "socket"
+
+module Necro
+  class Runner
+    def self.run(args)
+
+      selected_command = nil
+      
+      Slop.parse(args, help: true) do
+        on :v, "Print the version" do
+          $stdout.puts Necro::VERSION
+        end
+
+        command 'start' do
+          banner "Usage : necro start config.ini \n Start Necro Process Manager"
+          run do |cmd_opts, cmd_args|
+            selected_command = OpenStruct.new(:command => 'start', :file => cmd_args.first)
+          end
+        end
+
+        command 'add' do
+          banner "Usage : necro add process_label \n Start the process with given process_label"
+          run do |cmd_opts, cmd_args|
+            selected_command = OpenStruct.new(:command => 'add', :command_key => cmd_args.first)
+          end
+        end
+
+        command 'remove' do
+          banner "Usage : necro remove process_label \n Stop the process with given label"
+          on :s, :signal=, "Signal to send for killing the process, default is SIGINT", as: String
+
+          run do |cmd_opts, cmd_args|
+            signal_to_use = cmd_opts.to_hash[:signal] || 'INT'
+            selected_command = OpenStruct.new(
+              :command => 'remove', 
+              :command_key => cmd_args.first,
+              :signal => signal_to_use
+            )
+          end
+        end
+      end
+      run_command(selected_command)
+    end
+
+    def self.run_command(selected_command)
+      return unless selected_command
+      case selected_command.command
+      when 'start'
+        start_server(selected_command)
+      when 'add'
+        add_command(selected_command)
+      when 'remove'
+        remove_command(selected_command)
+      else
+        $stdout.puts "Invalid command"
+      end
+    end
+
+    def self.start_server(selected_command)
+      config = Necro::Config.new(selected_command.file)
+      Necro.const_set(:CONFIG, config)
+      warn_about_terminal_notifier()
+      commander = Necro::Commander.new()
+      Necro.const_set(:COMMANDER, commander)
+      commander.start_manager()
+    end
+
+    def self.add_command(selected_command)
+      socket = UNIXSocket.open(Necro::CommandListener::Server::SOCKET_PATH)
+      socket.puts("add #{selected_command.command_key}")
+      socket.flush()
+      socket.close()
+    end
+
+    def self.remove_command(selected_command)
+      socket = UNIXSocket.open(Necro::CommandListener::Server::SOCKET_PATH)
+      socket.puts("remove #{selected_command.command_key} #{selected_command.signal}")
+      socket.flush()
+      socket.close()
+    end
+
+    def self.refresh_command(selected_command)
+      socket = UNIXSocket.open(Necro::CommandListener::Server::SOCKET_PATH)
+      socket.puts("reload #{selected_command.command_key}")
+      socket.flush()
+      socket.close()
+    end
+
+    def self.warn_about_terminal_notifier
+      if RUBY_PLATFORM.downcase.include?("darwin")
+        command_path = `which terminal-notifier`
+        if !command_path || command_path.empty?
+          $stdout.puts("You can enable OSX notification for processes by installing terminal-notification gem".red)
+        end
+      end
+    end
+
+  end
+end

data/necro.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{necro}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hemant Kumar"]
+  s.date = %q{2013-05-04}
+  s.description = %q{Something small for process management}
+  s.email = %q{hemant@codemancers.com}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.homepage = %q{http://github.com/code-mancers/necro}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.summary = %q{Something small for Process management}
+  s.add_dependency("slop")
+  s.add_dependency("iniparse")
+  s.add_dependency("colored")
+  s.add_development_dependency("bacon")
+  s.add_development_dependency("mocha")
+  s.add_development_dependency("mocha-on-bacon")
+  s.add_development_dependency("rake")
+end
+

data/necro.ini.example

@@ -0,0 +1,13 @@
+[rails]
+directory = /home/gnufied/god_particle
+command = zsh -c 'bundle exec rails s -p 5000'
+
+[dj]
+directory = /home/gnufied/god_particle
+command = zsh -c 'bundle exec ruby script/delayed_job'
+
+
+[events]
+directory = /home/gnufied/god_particle
+command = zsh -c 'bundle exec ruby script/event_server'
+

data/readme.md

@@ -0,0 +1,47 @@
+Necro is a gem for managing processes in development environment.
+
+[![Build Status](https://travis-ci.org/code-mancers/necro.png)](https://travis-ci.org/code-mancers/necro)
+
+
+## Usage ##
+
+You need to start by creating a `ini` file which will define processes you want to manage using necro. An example
+`ini` file is included in the repo.
+
+    [rails]
+    directory = /home/gnufied/god_particle
+    command = zsh -c 'bundle exec rails s -p 5000'
+    
+    [dj]
+    directory = /home/gnufied/god_particle
+    command = zsh -c 'bundle exec ruby script/delayed_job'
+    
+    
+    [events]
+    directory = /home/gnufied/god_particle
+    command = zsh -c 'bundle exec ruby script/event_server'
+    
+After that you can start process manager via:
+
+    ~> necro start necro.ini
+    
+Above command will start all your processes in one terminal with their stdout/stderr merged and labelled.
+
+Now additionally you can control individual process by,
+
+    # Will try to stop running delayed job by sending SIGINT to the process
+    ~> necro remove dj
+
+    # If Process can't be killed by SIGINT send a custom signal
+    ~> necro remove dj -s 9
+
+    # add and start running
+    ~> necro add dj
+    
+You can also enable OSX notifications for crashed processes by installing `terminal-notification` gem. It is not a dependency, but can be useful if something crashed and you weren't paying attention.    
+    
+
+    
+
+
+

data/spec/necro/command_listener/client_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Necro::CommandListener::Client do
+  describe "add command" do
+    before do
+      @client_socket = mock()
+      @client = Necro::CommandListener::Client.new(@client_socket)
+    end
+    
+    it "should run if read from socket" do
+      necro_commander.expects(:add_command_by_label).with("foo")
+      @client_socket.expects(:read).returns("add foo\n")
+      @client_socket.expects(:close)
+
+      @client.read_and_execute()
+    end
+  end
+
+  describe "remove command" do
+    before do
+      @client_socket = mock()
+      @client = Necro::CommandListener::Client.new(@client_socket)
+    end
+
+    it "with specific signal" do
+      necro_commander.expects(:remove_command).with("foo", "9")
+      @client_socket.expects(:read).returns("remove foo 9\n")
+      @client_socket.expects(:close)
+
+      @client.read_and_execute()
+    end
+
+    it "with default signal" do
+      necro_commander.expects(:remove_command).with("foo",nil)
+      @client_socket.expects(:read).returns("remove foo\n")
+      @client_socket.expects(:close)
+
+      @client.read_and_execute()
+    end
+  end
+
+  describe "invalid command" do
+    before do
+      @client_socket = mock()
+      @client = Necro::CommandListener::Client.new(@client_socket)
+    end
+
+    it "should print error if read from socket" do
+      necro_commander.expects(:remove_command).never()
+      necro_commander.expects(:add_command_by_label).never()
+      @client_socket.expects(:read).returns("eugh foo\n")
+      @client_socket.expects(:close)
+
+      @client.read_and_execute
+    end
+  end
+end

data/spec/necro/command_worker_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe "Command Worker" do
+end

data/spec/necro/commander_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe "Necro::Commander" do
+  
+  describe "With no processes configured" do
+    before do
+      @commander = Necro::Commander.new()
+    end
+    
+    it "should throw error" do
+      necro_config.stubs(:processes).returns([])
+
+      lambda {
+        @commander.start_manager()
+      }.should.raise(Necro::Errors::InvalidConfig)
+    end
+  end
+
+  describe "#add_command_by_label" do
+    before do
+      @commander = Necro::Commander.new()
+    end
+
+    it "should find command by label and start it, if found" do
+      necro_config.stubs(:processes).returns([OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar")])
+      @commander.expects(:add_command).returns(true)
+      
+      @commander.add_command_by_label("resque")
+    end
+  end
+
+  describe "#remove_command" do
+    describe "when a worker is found" do
+      before do
+        @commander = Necro::Commander.new()
+        @commander.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      end
+
+      describe "if a signal is specified" do
+        it "should use that signal to kill the worker" do
+          @commander.expects(:process_kill).with("bogus", "HUP").returns(true)
+          @commander.remove_command("resque", "HUP")
+        end
+      end
+
+      describe "if no signal is specified" do
+        it "should use INT signal" do
+          @commander.expects(:process_kill).with("bogus", "INT").returns(true)
+          @commander.remove_command("resque", nil)
+        end
+      end
+    end
+
+    describe "when no worker is found" do
+      before do
+        @commander = Necro::Commander.new()
+        @commander.workers.expects(:[]).returns(nil)
+      end
+
+      it "should not kill anything" do
+        @commander.expects(:process_kill).never()
+        @commander.remove_command("resque", "HUP")
+      end
+    end
+
+  end
+
+  describe "#add_command" do
+    before do
+      necro_config.stubs(:processes).returns([OpenStruct.new(:label => "sleep", :cmd => "sleep 4", :dir => ENV['HOME'])])
+      @commander = Necro::Commander.new()
+    end
+
+    it "should populate workers and open_pipes" do
+      @commander.reactor.expects(:start).returns(true)
+      @commander.start_manager()
+      @commander.open_pipes.should.not.be.empty
+      @commander.workers.should.not.be.empty
+
+      worker = @commander.workers['sleep']
+
+      worker.should.not.equal nil
+      worker.command_label.should.equal "sleep"
+      worker.color.should.equal "green"
+
+
+      pipe_end_worker = @commander.open_pipes[worker.pipe_end.fileno]
+      pipe_end_worker.should.not.equal nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require "bacon"
+require "mocha-on-bacon"
+
+__LIB_PATH__ = File.join(File.dirname(__FILE__), "..")
+$: << __LIB_PATH__
+
+require "pry"
+require "necro"
+
+
+def necro_config
+  if Necro.const_defined?(:CONFIG)
+    Necro::CONFIG
+  else
+    Necro.const_set(:CONFIG, mock())
+    Necro::CONFIG
+  end
+end
+
+def necro_commander
+  if Necro.const_defined?(:COMMANDER)
+    Necro::COMMANDER
+  else
+    Necro.const_set(:COMMANDER, mock())
+    Necro::COMMANDER
+  end
+end
+
+

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: necro
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Hemant Kumar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  name: iniparse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: mocha-on-bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Something small for process management
+email: hemant@codemancers.com
+executables:
+- necro
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Rakefile
+- bin/necro
+- lib/necro.rb
+- lib/necro/command_listener.rb
+- lib/necro/command_listener/client.rb
+- lib/necro/command_listener/server.rb
+- lib/necro/command_worker.rb
+- lib/necro/commander.rb
+- lib/necro/config.rb
+- lib/necro/errors.rb
+- lib/necro/reactor.rb
+- lib/necro/runner.rb
+- necro.gemspec
+- necro.ini.example
+- readme.md
+- spec/necro/command_listener/client_spec.rb
+- spec/necro/command_worker_spec.rb
+- spec/necro/commander_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/code-mancers/necro
+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.3
+signing_key: 
+specification_version: 4
+summary: Something small for Process management
+test_files:
+- spec/necro/command_listener/client_spec.rb
+- spec/necro/command_worker_spec.rb
+- spec/necro/commander_spec.rb
+- spec/spec_helper.rb
+has_rdoc: