zeusd 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+before_install: bundle install --gemfile=spec/dummy/Gemfile
+bundler_args: --without tool
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zeusd.gemspec
+gemspec
+
+group :tool do
+  gem "guard-rspec"
+  gem "pry"
+  gem "pry-nav"
+end

data/Guardfile

@@ -0,0 +1,7 @@
+guard :rspec, :failed_mode => :none do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/zeusd/(.+)\.rb$})     { |m| "spec/lib/zeusd/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.md

@@ -0,0 +1,13 @@
+# Copyright (c) 1999 - 2014, Daniel Doezema
+
+## All rights reserved.
+
+* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+The names of the contributors and/or copyright holder may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DANIEL DOEZEMA BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,48 @@
+# Zeusd
+
+Run the Zeud Gem as a daemon
+
+[![Build Status](https://travis-ci.org/veloper/zeusd.png?branch=master)](https://travis-ci.org/veloper/zeusd) [![Code Climate](https://codeclimate.com/github/veloper/zeusd.png)](https://codeclimate.com/github/veloper/zeusd)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zeusd'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zeusd
+
+## Usage
+
+### Commands
+
+```
+zeusd start [--block]
+zeusd stop
+zeusd restart
+```
+
+### Global Flags
+* `--cwd=current/work/directory/of/rails/app` or alias `-d`
+* `--verbose` or `-v`
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write and test your changes
+3. Commit your changes and specs (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+* Zeusd is released under the New BSD license. http://dan.doezema.com/licenses/new-bsd/

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/bin/zeusd

@@ -0,0 +1,42 @@
+require "thor"
+require "zeusd"
+
+class ZeusdCLI < Thor
+  class_option :verbose,  :type => :boolean,  :aliases => :v
+  class_option :block,    :type => :boolean,  :aliases => :b
+  class_option :cwd,      :type => :string,   :aliases => :d
+  class_option :log,      :type => :string,   :aliases => :l
+
+  desc "start", "."
+  def start
+    daemon.start! :block => options[:block]
+  end
+
+  desc "restart", "."
+  def restart
+    stop
+    start
+  end
+
+  desc "stop", "."
+  def stop
+    daemon.stop!
+  end
+
+  desc "status", "."
+  def status
+    # Zeusd::Daemon.new(options).stop!
+  end
+
+  protected
+
+  def daemon
+    Zeusd::Daemon.new(
+      :verbose  => options[:verbose],
+      :cwd      => options[:cwd]
+    )
+  end
+
+end
+
+ZeusdCLI.start(ARGV)

data/lib/zeusd.rb

@@ -0,0 +1,8 @@
+require 'zeusd/version'
+require 'zeusd/process'
+require 'zeusd/state_interpreter'
+require 'zeusd/daemon'
+
+module Zeusd
+
+end

data/lib/zeusd/daemon.rb

@@ -0,0 +1,104 @@
+require 'thread'
+require 'childprocess'
+require 'pathname'
+
+module Zeusd
+  class DaemonException < StandardError; end
+
+  class Daemon
+    attr_reader :cwd, :verbose
+    attr_reader :queue
+    attr_reader :state
+    attr_reader :child_process, :reader, :writer
+
+    def initialize(options = {})
+      @cwd     = Pathname.new(options.fetch(:cwd, Dir.pwd)).realpath
+      @verbose = options.fetch(:verbose, false)
+      @queue   = Queue.new
+      @state   = StateInterpreter.new
+      on_update(&method(:puts)) if verbose
+    end
+
+    def stop!
+      processes = process ? Array([process.descendants, process]).flatten : []
+      if processes.any?
+        Zeusd::Process.kill!(processes.map(&:pid))
+      end
+      (socket_file.delete rescue nil) if socket_file.exist?
+      if (alive_processes = processes).all?(&:alive?)
+        raise DaemonException, "Unable to KILL processes: " + alive_processes.join(', ')
+      else
+        @process = nil
+        true
+      end
+    end
+
+    def start!(options = {})
+      @process = Zeusd::Process.find(start_child_process!.pid)
+
+      if options.fetch(:block, false)
+        loop do
+          if loaded?
+            puts state.last_status
+            break
+          end
+          sleep(0.1)
+        end
+      end
+
+      process
+    end
+
+    def process
+      @process ||= Process.all.find do |p|
+        !!p.command[/zeus.*start$/] && p.cwd == cwd
+      end
+    end
+
+    def loaded?
+      process.descendants.all?(&:asleep?)
+    end
+
+    def on_update(&block)
+      @on_update = block if block_given?
+      @on_update
+    end
+
+    def socket_file
+      cwd.join('.zeus.sock')
+    end
+
+    protected
+
+    def start_child_process!
+      @reader, @writer = IO.pipe
+      @child_process = ChildProcess.build("zeus", "start")
+      @child_process.environment["BUNDLE_GEMFILE"] = cwd.join("Gemfile").to_path
+      @child_process.io.stdout = @child_process.io.stderr = @writer
+      @child_process.cwd       = cwd.to_path
+      @child_process.detach    = true
+      @child_process.start
+      @writer.close
+
+      Thread.new do
+        while (buffer = (reader.readpartial(10000) rescue nil)) do
+          state << buffer
+          queue << buffer
+        end
+      end
+
+      if on_update.is_a?(Proc)
+        Thread.new do
+          while output = queue.pop
+            on_update.call(output)
+          end
+        end
+      end
+
+      sleep(0.1) until state.commands.any?
+
+      @child_process
+    end
+
+  end
+end

data/lib/zeusd/process.rb

@@ -0,0 +1,141 @@
+module Zeusd
+  class Process
+    CASTINGS = {
+      "pid"     => ->(x){x.to_i},
+      "ppid"    => ->(x){x.to_i},
+      "pgid"    => ->(x){x.to_i},
+      "stat"    => ->(x){x.to_s},
+      "command" => ->(x){x.to_s}
+    }
+    attr_accessor :attributes
+    attr_accessor :children
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    def self.ps(options = {})
+      keywords = Array(options[:keywords]) | %w[pid ppid pgid stat command]
+      command  = ["ps"].tap do |ps|
+        ps << "-o #{keywords.join(',')}"
+        ps << "-p #{options[:pid].to_i}" if options[:pid]
+      end.join(" ")
+      header, *rows = `#{command}`.split("\n")
+      keys          = header.downcase.split
+      glob_columns  = 0...(keys.length-1)
+      cmd_columns   = (keys.length-1)..-1
+      Array(rows.map(&:split)).map do |parts|
+        Hash[keys.zip(parts[glob_columns] << parts[cmd_columns].join(" "))] # Attributes
+      end
+    end
+
+    def self.all(options = {})
+      ps(options).map do |attributes|
+        self.new(attributes)
+      end
+    end
+
+    # Note: Non-chinable, AND joined, Proc allowed for value
+    # {"attr" => value}
+    def self.where(criteria, options = {})
+      all(options).select do |process|
+        criteria.all? do |key, value|
+          case value
+          when Array then value.include?(process.send(key))
+          when Proc  then !!value.call(process)
+          else
+            process.send(key) == value
+          end
+        end
+      end
+    end
+
+    def self.find(pid)
+      if attributes = ps(:pid => pid).first
+        self.new(attributes)
+      end
+    end
+
+    def self.kill!(pids, options = {})
+      signal = options.fetch(:signal, "INT")
+      pids   = Array(pids).map(&:to_i).select{|x| x > 0}
+      if pids.any?
+        system("kill -#{signal} #{pids.join(' ')}")
+        $?.success?
+      else
+        false
+      end
+    end
+
+    def reload!
+      self.attributes = self.class.ps(:pid => pid).first || {}
+      @children   = nil
+      !attributes.empty?
+    end
+
+    def cwd
+      @cwd ||= (path = `lsof -p #{pid}`.split("\n").find{|x| x[" cwd "]}.split.last.strip) ? Pathname.new(path).realpath : nil
+    end
+
+    def pid
+      attributes["pid"]
+    end
+
+    def ppid
+      attributes["ppid"]
+    end
+
+    def pgid
+      attributes["pgid"]
+    end
+
+    def state
+      reload!
+      attributes["stat"]
+    end
+
+    def command
+      attributes["command"]
+    end
+
+    def asleep?
+      !!state.to_s["S"]
+    end
+
+    def alive?
+      reload!
+      !attributes.empty?
+    end
+
+    def dead?
+      !alive?
+    end
+
+    def kill!(options = {})
+      self.class.kill!(pid, options)
+      reload!
+    end
+
+    def descendants(options = {})
+      children(options).map do |child_process|
+        [child_process].concat(Array(child_process.descendants))
+      end.flatten.compact
+    end
+
+    def children(options = {})
+      @children = self.class.where("ppid" => pid).tap do |processes|
+        if options.fetch(:recursive, false)
+          processes.each{|p| p.children(options)}
+        end
+      end
+    end
+
+    def attributes=(hash)
+      @attributes = hash.reduce({}) do |seed, (key, value)|
+        value = CASTINGS[key] ? CASTINGS[key].call(value) : value
+        seed.merge(key => value)
+      end
+    end
+
+  end
+end

data/lib/zeusd/state_interpreter.rb

@@ -0,0 +1,89 @@
+require 'stringio'
+module Zeusd
+  class StateInterpreter
+    STATES = %w[ready crashed running connecting waiting]
+
+    attr_reader :lines
+    attr_reader :state_colors, :commands, :errors
+
+    def initialize(*args)
+      @state_colors = Hash[STATES.zip([nil]*STATES.length)]
+      @commands     = {}
+      @errors       = []
+      @lines        = []
+      super(*args)
+    end
+
+    def <<(input)
+      input.split("\n").map{|x| Line.new(x) }.each do |line|
+        # State Colors
+        if @state_colors.values.any?(&:nil?) && line.legend?
+          STATES.each do |state|
+            state_colors[state] = line.color_of(state)
+          end
+        end
+
+        # Errors
+        @errors << line if line.color == state_colors["crashed"]
+
+        # Commands
+        @commands[line.command[:name]] = state_colors.invert[line.command[:color]] if line.command?
+
+        # Add Line
+        @lines << line
+      end
+    end
+
+    def is_complete?
+      return false if errors.any?
+      return true if commands.all? {|command, status| %[crashed running].include?(status)}
+      false
+    end
+
+    def last_status
+      @lines[@lines.rindex(&:update?)..-1].join("\n").to_s
+    end
+
+    class Line < String
+
+      def update?
+        self =~ /\=\=\=\=$/
+      end
+
+      def command?
+        !!command
+      end
+
+      def command
+        if match = self.match(/^(\e.*?)zeus\s(.*?)(\s|\e)/)
+          { :name => match[2], :color => match[1] }
+        end
+      end
+
+      def legend?
+        STATES.all?{|state| !!self[state]}
+      end
+
+      def color_of(substring)
+        if stop_point = index(substring) + substring.length
+          if color_start = rindex(/\e/, stop_point)
+            color_end = index('m', color_start)
+            self[color_start..color_end]
+          end
+        end
+      end
+
+      def color
+        if self[0] == "\e" && !self.index('m').nil?
+          self[0..self.index('m')]
+        end
+      end
+
+      def color?
+        !!color
+      end
+
+    end
+
+  end
+end