console-mux 2.0.2

data/bin/console-mux

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/console/mux'
+
+#require 'ruby-debug'
+#Debugger.start
+
+Console::Mux.run_argv
+

data/lib/console/mux.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2012 Common Ground Publishing
+#
+# 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.
+#
+
+require 'optparse'
+
+require 'console/mux/console'
+
+module Console
+  module Mux
+    include Log4r
+
+    BUNDLE_EXEC_SH = File.expand_path('bundle_exec.sh',
+                                      File.join(__FILE__, '..', 'mux'))
+
+    # @param [Array] args commandline arguments
+    def self.run_argv(args = ARGV)
+      options = {
+        :init_file => nil
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: console-mux <init_file>"
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+        opts.on('-f', '--init=FILE', 'Load this init file') do |file|
+          options[:init_file] = file
+        end
+      end.parse!(args)
+
+      begin
+        run(options)
+      rescue Errno::ENOENT => e
+        $stderr.puts e.message
+        $stderr.puts e.backtrace.join("\n    ")
+        exit 1
+      end
+    end
+
+    def self.run(options)
+      Console.new(options)
+    end
+  end
+end

data/lib/console/mux/buffer_outputter.rb

@@ -0,0 +1,55 @@
+#
+# Copyright (C) 2012 Common Ground Publishing
+#
+# 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.
+#
+require "log4r/outputter/outputter"
+require "log4r/staticlogger"
+
+require 'console/mux/rolling_array'
+
+module Console
+
+  module Mux
+
+    # A Log4r outputtter that captures a rolling buffer of logged
+    # messages.
+    class BufferOutputter < Log4r::Outputter
+
+      def initialize(_name, size, hash={})
+        @buffer = RollingArray.new(size)
+        super(_name, hash)
+      end
+
+      # Iterate through each captured log line.
+      def each(*args, &block)
+        @buffer.each(*args, &block)
+      end
+
+      private
+
+      # write to buffer
+      def write(data)
+        @buffer << data
+      end
+
+    end
+
+  end
+
+end

data/lib/console/mux/bundle_exec.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# bundle_exec.sh - emulate 'bundle exec' but with a shell script
+# rather than a ruby script.  Modifies the environment just like
+# bundle exec would.
+#
+# Running "bundle exec ruby" starts a ruby in which then execs the
+# command, 'ruby'.  In JRuby 1.6, the command is started in a child
+# process.  When using a Foreman-like tool that has the ability to
+# kill and/or restart such a command, only the parent will be killed
+# while the child ruby continues on.  This bundle_exec.sh wokrs
+# similarly to bundle exec, but the exec is done in the shell rather
+# than in JRuby to avoid the difficult-to-kill child process.
+#
+# For bourne-compatible shells.
+#
+# Author: Patrick Mahoney <pat@polycrystal.org>
+
+# Run 'bundle exec' in a subshell; echo a string that when eval'ed
+# will duplicate the 'bundle exec' environment.
+env=$(bundle exec sh -c \
+     'echo "export BUNDLE_BIN_PATH=\"$BUNDLE_BIN_PATH\"; \
+            export PATH=\"$PATH\"; \
+            export BUNDLE_GEMFILE=\"$BUNDLE_GEMFILE\"; \
+            export RUBYOPT=\"$RUBYOPT\"";')
+
+ret="$?"
+if [ "$ret" = 0 ]; then
+  # Bring bundle exec environment into the current shell.
+  eval $env
+  exec "$@"
+else
+  echo "$env"
+  exit "$ret"
+fi

data/lib/console/mux/color_formatter.rb

@@ -0,0 +1,110 @@
+#
+# Copyright (C) 2012 Common Ground Publishing
+#
+# 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.
+#
+require 'log4r'
+
+class String
+  # DJB hash algorithm 2.  The default Ruby string hash is not stable
+  # across Ruby invocations (for security reasons).
+  def hash_djb2
+    hash = 5381
+    each_codepoint do |c|
+      hash = ((hash << 5) + hash) + c # equiv. hash * 33 + c?
+    end
+    hash
+  end
+end
+
+module Console
+
+  module Mux
+
+    class ColorFormatter < Log4r::BasicFormatter
+      BASIC_COLORS = {
+        :black => 0,
+        :red => 1,
+        :green => 2,
+        :yellow => 3,
+        :blue => 4,
+        :magenta => 5,
+        :cyan => 6,
+        :grey => 7,
+      }
+
+      # On 256 color term, many colors beyond 127 seem to be
+      # unreadably light.  Of course, if your terminal has a dark
+      # background that may be preferable.
+      N_COLORS = [127, `tput colors`.to_i].min
+
+      COLOR_STRINGS = []
+      N_COLORS.times do |i|
+        COLOR_STRINGS[i] = `tput setaf #{i}`
+      end
+
+      RESET_COLORS = `tput sgr0`      # last string is reset
+
+      MAX_WIDTH = 35
+      MIN_WIDTH = 8
+
+      attr_accessor :label_width
+
+      def initialize(hash={})
+        super(hash)
+        @label_width = MIN_WIDTH
+        @colors = Hash.new
+      end
+
+      def format(event)
+        self.label_width = [[self.label_width, event.name.size].max, MAX_WIDTH].min
+
+        color, name = case event.name
+               when 'process'
+                 [:red, '-' * label_width]
+               else
+                 [color_for(event.name), event.name]
+               end
+
+        "%s%-#{label_width}s|%s %s" %
+          [set_color_str(color), name, unset_color_str, event.data]
+      end
+
+      protected
+
+      def color_for(name)
+        @colors[name] ||= name.hash_djb2 % N_COLORS
+      end
+
+      def set_color_str(color)
+        c = if color.kind_of? Symbol
+              BASIC_COLORS[color]
+            else
+              color
+            end
+        COLOR_STRINGS[c]
+      end
+
+      def unset_color_str
+        RESET_COLORS
+      end
+    end
+
+  end
+
+end

data/lib/console/mux/command.rb

@@ -0,0 +1,134 @@
+#
+# Copyright (C) 2012 Common Ground Publishing
+#
+# 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.
+#
+require 'console/mux/util'
+require 'console/mux/process'
+require 'console/mux/run_with'
+require 'pathname'
+
+module Console
+  module Mux
+    class Command
+      include Util
+
+      class << self
+        def option_reader(*syms)
+          syms.each do |sym|
+            define_method(sym) do
+              self[sym]
+            end
+          end
+        end
+
+        def option_writer(*syms)
+          syms.each do |sym|
+            define_method("#{sym}=") do |val|
+              self[sym] = val
+            end
+          end
+        end
+
+        def option_accessor(*syms)
+          option_reader(*syms)
+          option_writer(*syms)
+        end
+      end
+
+      attr_reader :opts, :commandline
+
+      option_accessor :name, :command, :env, :run_with, :chdir
+
+      # @param opts execution options arbitrary keys and values, but some are special
+      #
+      # @option opts [Boolean] :noop if true, the command will not be
+      # run (debugging convenience)
+      #
+      # @option opts [String] :command the command to run, e.g. +ls -l+
+      #
+      # @option opts [String] :name the name of the command; if
+      # missing, a name will be auto-generated from the command
+      #
+      # @option opts [String] :chdir change to this dir before running the command
+      #
+      # @option opts [String] :run_with An array of filters.  The filters are
+      # applied to the command in reverse order.  A string filter is
+      # simply prepended to the command.  A symbol is called as a method
+      # on RunWith that accepts `(command, opts)` args and returns
+      # `[new_command, new_opts]`.
+      def initialize(opts)
+        @opts = opts.dup
+
+        self.env ||= {}
+        self.run_with ||= []
+
+        # name need not be unique here.  When added to a CommandSet,
+        # within that set it may be assigned a unique name based off
+        # this name.
+        self.name ||= auto_name(command)
+
+        @commandline = expand
+      end
+
+      def [](key)
+        value = opts[key]
+        if value.respond_to? :call
+          value.call(self)
+        else
+          value
+        end
+      end
+
+      # Set an option on this command.  The +value+ may be a Proc
+      # object taking a single argument (or anything that responds to
+      # +:call+), in which case the value on get (+#[]) will be the
+      # result of that Proc called with +self+.
+      def []=(key, value)
+        opts[key] = value
+      end
+
+      def dir
+        dir = self[:chdir] || '.'
+        if self[:base_dir] && !Pathname.new(dir).absolute?
+          File.join(self[:base_dir], dir)
+        else
+          dir
+        end
+      end
+
+      def to_s
+        commandline.sub(/^#{::Console::Mux::BUNDLE_EXEC_SH}/, '*bundle_exec.sh')
+      end
+
+      private
+      
+      # Apply any +:run_with+ options to generate the expanded
+      # commandline that should be executed.
+      def expand
+        run_with.reverse.reduce(command) do |commandline, filter|
+          if RunWith.respond_to?(filter)
+            RunWith.send(filter, self, commandline)
+          else
+            "#{filter} #{commandline}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/console/mux/command_set.rb

@@ -0,0 +1,235 @@
+#
+# Copyright (C) 2012 Common Ground Publishing
+#
+# 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.
+#
+require 'console/mux/events'
+
+module Console
+  module Mux
+    class CommandSet
+      include Console::Mux::Events
+
+      class << self
+        # Yield to the block only after all processes are stopped.
+        # Does not check that all processes are actually running; just
+        # waits for an +:exit+ event from each.
+        #
+        # @param [Array<Process>] processes
+        def join(processes)
+          pending_exit = processes.size
+          processes.each do |proc|
+            proc.on(:exit) do
+              pending_exit -= 1
+              if pending_exit == 0 && block_given?
+                yield
+              end
+            end
+          end
+        end
+      end
+
+      attr_reader :max_width
+
+      def initialize
+        @max_width = 0
+        @commands = Array.new
+        @commands_by_name = Hash.new
+
+        @processes = Hash.new
+        @stopped_at = Hash.new
+      end
+
+      # Add a command (see #add) and start it (see #start).
+      def add_and_start(command)
+        name = add(command)
+        start(name)
+      end
+
+      # Add a command to this CommandSet.
+      #
+      # @param [Command] command
+      #
+      # @return [String] the command name, which may be different from
+      # +command.name+ if required to be unique within this CommandSet
+      def add(command)
+        name = unique_name(command.name)
+
+        @commands << command
+        @commands_by_name[name] = command
+        @max_width = [@max_width, name.size].max
+
+        name
+      end
+
+      def remove(name)
+        return unless @commands_by_name[name]
+
+        stop(name) rescue nil
+        @stopped_at.delete(name)
+        @commands.delete(@commands_by_name.delete(name))
+      end
+
+      # TODO: make this work?
+      # def merge(command)
+      #   if i = @commands.first_index(command)
+      #     @commands[i] = command
+      #     @commands_by_name[command.name] = command
+      #   else
+      #     add(command)
+      #   end
+      # end
+
+      def include?(command)
+        @commands.include?(command)
+      end
+
+      def stopped?
+        @processes.empty?
+      end
+
+      def each(&block)
+        @commands.each(&block)
+      end
+
+      def [](name)
+        @commands_by_name[name]
+      end
+
+      def start(name)
+        if proc = @processes[name]
+          raise "already have process for #{name}: #{proc.pid}"
+        end
+        
+        @stopped_at.delete(name)
+        proc = Process.start(@commands_by_name[name], name)
+        proc.on(:exit) do
+          @processes.delete(name)
+          @stopped_at[name] = Time.now
+          fire(:stopped) if @processes.empty?
+        end
+        @processes[name] = proc
+        proc
+      end
+
+      def stop(name)
+        if proc = @processes.delete(name)
+          proc.stop
+        else
+          raise "no process for #{name}"
+        end
+      end
+
+      def stop_all
+        @processes.each do |name, proc|
+          proc.stop
+        end
+      end
+
+      # When all currently-running processes stop, yield to the block
+      def join(&block)
+        self.class.join(@processes.values, &block)
+      end
+
+      # Stop and then start the process +name+.
+      def restart(name)
+        if proc = @processes[name]
+          proc.on(:exit) do
+            start(name)
+          end
+          proc.stop
+        elsif @commands_by_name[name]
+          start(name)
+        else
+          raise "no process for #{name}"
+        end
+      end
+
+      def pretty_seconds(secs)
+        if secs < 60
+          "#{secs} s"
+        elsif secs < (60 * 60)
+          "#{secs/60} min"
+        elsif secs < (60 * 60 * 24)
+          "#{secs/60/60} hr"
+        else
+          "%0.1f days" % (secs/60.0/60.0/24.0)
+        end
+      end
+
+      def pretty_bytes(bytes)
+        if bytes < 1024
+          "#{bytes}B"
+        elsif bytes < 1024 * 1024
+          "#{bytes/1024} kiB"
+        elsif bytes < 1024* 1024 * 1024
+          "#{bytes/1024/1024} MiB"
+        else
+          "%0.2d GiB" % (bytes.to_f/(1024**3))
+        end
+      end
+
+      def status
+        fmt = "%-#{max_width}s %8s %12s %8s %10s\n"
+
+        rows = []
+        rows << fmt % ['NAME', 'PID', 'RSS', 'TIME', 'CPUTIME']
+        @commands_by_name.each do |name, c|
+          pid, rss, time, cputime =
+            if proc = @processes[name]
+              [proc.pid.to_s,
+               pretty_bytes(proc.rss),
+               proc.etime,
+               proc.cputime]
+            elsif @stopped_at[name]
+              downtime = Time.now.to_i - @stopped_at[name].to_i
+              ['-', "  down #{pretty_seconds(downtime)}", nil, nil]
+            else
+              ['-', "        (pending)", nil, nil]
+            end
+          
+          rows << (fmt % [name, pid, rss, time, cputime])
+        end
+
+        rows
+      end
+
+      def count
+        "#{@commands.size} commands with #{@processes.size} running"
+      end
+
+      private 
+
+      # Generate a unique command name based on `name`.  If there is
+      # already a command `name`, a digit will be appended, starting
+      # at 2, and increasing until an unused name is found.
+      def unique_name(name)
+        if @commands_by_name.include?(name)
+          count = 2
+          name2 = nil
+          while (name2 = name + count.to_s) && @commands_by_name.include?(name2)
+            count += 1
+          end
+          name2
+        else
+          name
+        end
+      end
+    end
+  end
+end