console-mux 2.0.2

data/lib/console/mux/console.rb

@@ -0,0 +1,288 @@
+#
+# 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 'eventmachine'
+require 'log4r'
+require 'ripl/readline/em'
+
+require 'console/mux/buffer_outputter'
+require 'console/mux/command'
+require 'console/mux/command_set'
+require 'console/mux/console_outputter'
+require 'console/mux/color_formatter'
+require 'console/mux/pty_handler'
+require 'console/mux/shell'
+
+
+module Console
+  module Mux
+    class Console
+      include Log4r
+
+      MARK_PERIOD = 60            # seconds
+
+      BUFFER_LINES = 10000
+
+      attr_reader :commands, :default_options, :formatter, :buffer, :logger
+
+      def initialize(options={})
+        @commands = CommandSet.new
+        @default_options = Hash.new
+        @base_dir = '.'
+
+        @formatter = ColorFormatter.new
+
+        @logger = Logger.new('process')
+        logger.add ConsoleOutputter.new('console',
+                                        self,
+                                        :formatter => formatter)
+
+        @buffer = BufferOutputter.new('buffer',
+                                      BUFFER_LINES,
+                                      :formatter => formatter)
+        logger.add @buffer
+
+        EventMachine.run do
+          logger.info { 'Initializing' }
+
+          EventMachine.add_periodic_timer(MARK_PERIOD) do
+            now = Time.now.strftime('%Y-%m-%d %H:%M')
+            logger.info { "#{now} have #{commands.count}" }
+          end
+
+          EventMachine.next_tick do
+            load(options[:init_file]) if options[:init_file]
+          end
+
+          @shell = Shell.new(self)
+          Ripl.start :binding => @shell.instance_eval { binding }
+          EventMachine.watch_stdin(Ripl::Readline::EmInput,
+                                   :on_exit => proc { shutdown })
+        end
+      end
+
+      def load(file)
+        old_base = @base_dir
+        @base_dir = File.expand_path(File.dirname(file))
+        begin
+          @shell.instance_eval(File.read(file), file)
+          @last_file = file
+        ensure
+          @base_dir = old_base
+        end
+      end
+
+      def run_commands()
+        next_command = commands.command_q.shift
+        if (!next_command.nil?)
+          commands.startCommand( next_command )
+
+#          if next_command.opts[:blocking]
+#            EventMachine.next_tick do
+#              check_command(next_command) 
+#            end
+#          else
+#          end
+
+          if (!(commands.command_q.empty?))
+            EventMachine.next_tick do
+              run_commands() 
+            end
+          end
+        end
+
+        # EM::Iterator requires the beta version of eventmachine
+#        EM::Iterator.new(commands.command_q).each do |command,iter| 
+#          commands.start( commands.command_q.shift )
+#          iter.next
+#        end
+      end
+
+
+      # Using set_ rather than '=' style accessor so config file needn't
+      # use self.default_options =.
+      def set_default_options(opts)
+        @default_options = opts
+      end
+
+      # Run a single command, a sequence of commands, or a sequence of
+      # single and parallel commands with default shell argument
+      # expansion.
+      #
+      # Each options hash is merged with the default options and then
+      # passed to +Command.new+.
+      #
+      # If multiple command options are given, run them sequentially
+      # one-at-a-time.  Only the final command will remain in the
+      # active command list; the others will be removed as they
+      # complete and exit.
+      #
+      # If an array of command options is given, they will be run in
+      # parallel, even if part of sequential sequence.  Thus you can
+      # specify +run(c1, c2, [c3,c4,c5], c6)+ which will run commands
+      # 1 and 2 sequentially, then 3, 4 and 5 in parallel, then
+      # finally command 6 only after all previous commands complete.
+      #
+      # In the following example, the first +ls+ is run, and when it
+      # exits the next two +ls+ instances are spawned in parallel.
+      # When those two exit, the final +ls+ is run.
+      #
+      #        run({:command => 'ls'},
+      #           [{:command => 'ls'}, {:command => 'ls'}],
+      #           {:command => 'ls'})
+      #
+      # @param [Hash] *opts one or more option hashes passed to +Command.new+.
+      def run(*optses)
+        names = optses.map do |opts|
+          if opts.kind_of? Array
+            opts.map { |o| make_command_and_add(o) }
+          else
+            make_command_and_add(opts)
+          end
+        end
+
+        seq_names(names.compact)
+      end
+
+      def make_command(opts)
+        opts = @default_options.merge(opts)
+        return if opts[:noop]
+
+        opts[:base_dir] = @base_dir
+
+        begin
+          Command.new(opts)
+        rescue => e
+          # optimistically assume console-mux errors are uninteresting
+          first_relevant = e.backtrace.find { |line| !(line =~ %r{lib/console/mux}) }
+          # logger.error e.backtrace.join("\n\t")
+          logger.error { "#{opts[:command]}: #{e.message} at #{first_relevant}" }
+          nil
+        end
+      end
+      private :make_command
+
+      # @return [String, nil] the name of the command or nil if
+      # command was noop or if there was an error
+      def make_command_and_add(opts)
+        if c = make_command(opts)
+          commands.add(c)
+        end
+      end
+      private :make_command_and_add
+
+      def seq_names(names)
+        return unless names.size > 0
+
+        name_or_ary = names.shift
+        EventMachine.next_tick do
+          # name may be a single name or array of names, so we
+          # normalize everything to an array
+          to_start = [name_or_ary].flatten
+          procs = to_start.map { |n| start(n) }
+          
+          CommandSet.join(procs) do
+            if names.size > 0
+              to_start.each { |n| commands.remove(n) }
+              seq_names(names)
+            end
+          end
+        end
+      end
+      private :seq_names
+
+      def status
+        puts commands.status
+      end
+
+      # Stop all commands in the command set, then destroy the command
+      # set, starting with an empty one.
+      def reset(&block)
+        old_commands = commands
+        @commands = CommandSet.new
+        old_commands.join(&block)
+      end
+
+      def stop(name)
+        logger.info { "Stopping #{name}" }
+        commands.stop(name)
+      end
+
+      def start(name)
+        logger.info { "Starting #{name}" }
+        commands.start(name)
+      end
+
+      def restart(name)
+        logger.info { "Restarting #{name}" }
+        commands.restart(name)
+      end
+
+      def shutdown
+        if commands.stopped?
+          EventMachine.stop_event_loop
+        else
+          timer = EventMachine.add_timer(30) do
+            logger.error { "could not halt all processes; giving up :(" }
+            EventMachine.stop_event_loop
+          end
+
+          commands.on(:stopped) do
+            EventMachine.cancel_timer(timer)
+            EventMachine.stop_event_loop
+          end
+
+          commands.stop_all
+        end
+      end
+
+      def lastlog(arg=//)
+        regex = case arg
+                when String
+                  if arg.eql?(arg.downcase)
+                    /#{arg}/i
+                  else
+                    /#{arg}/
+                  end
+                when Regexp
+                  arg
+                else
+                  raise ArgumentError, 'need string or regexp'
+                end
+
+        @buffer.each do |msg|
+          puts msg if msg =~ regex
+        end
+      end
+
+      def puts(message = '')
+        # See http://stackoverflow.com/questions/1512028/gnu-readline-how-do-clear-the-input-line
+        print "\b \b" * Readline.line_buffer.size
+        print "\r"
+        begin
+          $stdout.puts message
+          $stdout.flush
+        ensure
+          ::Readline.forced_update_display
+        end
+      end
+    end
+  end
+end

data/lib/console/mux/console_outputter.rb

@@ -0,0 +1,60 @@
+#
+# 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"
+
+module Console
+
+  module Mux
+    
+    ##
+    # IO Outputter invokes print then flush on the wrapped IO
+    # object. If the IO stream dies, IOOutputter sets itself to OFF
+    # and the system continues on its merry way.
+    #
+    # To find out why an IO stream died, create a logger named 'log4r'
+    # and look at the output.
+
+    class ConsoleOutputter < Log4r::Outputter
+
+      def initialize(_name, console, hash={})
+        @console = console
+        super(_name, hash)
+      end
+
+      private
+
+      # perform the write (copied from Log4r::IOOutputter but uses console.puts)
+      def write(data)
+        begin
+          @console.puts data
+        rescue => e # recover from this instead of crash
+          Log4r::Logger.log_internal {"IOError in Outputter '#{@name}'!"}
+          Log4r::Logger.log_internal {e}
+          raise e
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/console/mux/env_with_merged.rb

@@ -0,0 +1,45 @@
+#
+# 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.
+#
+class << ENV
+  # Merge the values from `hash` into the global ENV; yield the block;
+  # restore the original values of ENV.
+  #
+  # @param [Hash] hash
+  def with_merged(hash)
+    ENV.restore do
+      ENV.update(hash)
+      yield
+    end
+  end
+
+  # Not threadsafe.  Save the current ENV, yield to the block, then restore the original ENV.
+  def restore
+    # save original values
+    orig = ENV.to_hash
+    
+    begin
+      yield
+    ensure
+      ENV.clear
+      ENV.update(orig)
+    end
+  end
+end

data/lib/console/mux/events.rb

@@ -0,0 +1,41 @@
+#
+# 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.
+#
+module Console
+  module Mux
+    module Events
+      def event_handlers
+        @event_handlers ||= Hash.new { |h,k| h[k] = Array.new }
+      end
+
+      def on(event, &handler)
+        event_handlers[event] << handler
+      end
+
+      protected
+
+      def fire(event, *args)
+        event_handlers[event].each do |handler|
+          handler.call(event, self, *args)
+        end
+      end
+    end
+  end
+end

data/lib/console/mux/object_compose.rb

@@ -0,0 +1,32 @@
+#
+# 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.
+#
+class Object
+  # For each symbol in `syms`, call the corresponding method with
+  # `*args`, then call subsequent methods with the return value of the
+  # previous call.
+  #
+  # @return [Object] the value of the last method called
+  def compose(syms, *args)
+    syms.reduce(args) do |args, sym|
+      method(sym).call(*args)
+    end
+  end
+end