multi_process 0.1.0

data/README.md

@@ -0,0 +1,67 @@
+# MultiProcess
+
+Handle multiple processes.
+
+TODO: Just experiment.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'multi_process'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install multi_process
+
+## Usage
+
+```
+receiver = MultiProcess::Logger $stdout, $stderr, sys: false
+group = MultiProcess::Group.new receiver: receiver
+group << MultiProcess::Process.new %w(ruby test.rb), title: 'rubyA'
+group << MultiProcess::Process.new %w(ruby test.rb), title: 'rubyB'
+group << MultiProcess::Process.new %w(ruby test.rb), title: 'rubyC'
+group.start # Start in background
+group.run   # Block until finished
+group.wait  # Wait until finished
+group.stop  # Stop processes
+```
+
+```
+(23311) rubyB | Output from B
+(23308) rubyA | Output from A
+(23314) rubyC | Output from C
+(23314) rubyC | Output from C
+(23311) rubyB | Output from B
+(23308) rubyA | Output from A
+``
+
+## Contributing
+
+1. Fork it ( http://github.com/jgraichen/multi_process/fork )
+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
+
+## License
+
+Copyright (C) 2014  Jan Graichen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/multi_process.rb

@@ -0,0 +1,15 @@
+require 'multi_process/version'
+require 'childprocess'
+
+module MultiProcess
+  DEFAULT_TIMEOUT = 60
+
+  require 'multi_process/group'
+  require 'multi_process/receiver'
+  require 'multi_process/nil_receiver'
+  require 'multi_process/logger'
+
+  require 'multi_process/process'
+  require 'multi_process/process/rails'
+  require 'multi_process/process/bundle_exec'
+end

data/lib/multi_process/group.rb

@@ -0,0 +1,136 @@
+module MultiProcess
+
+  # Store and run a group of processes.
+  #
+  class Group
+
+    # Return list of processes.
+    attr_reader :processes
+
+    # Receiver all processes in group should use.
+    #
+    # If changed only affect new added processes.
+    #
+    attr_accessor :receiver
+
+    # Create new process group.
+    #
+    # @param opts [ Hash ] Options
+    # @option otps [ Receiver ] :receiver Receiver to use for new added
+    #   processes. Defaults to `MultiProcess::Logger.global`.
+    #
+    def initialize(opts = {})
+      @processes = []
+      @receiver  = opts[:receiver] ? opts[:receiver] : MultiProcess::Logger.global
+    end
+
+    # Add new process or list of processes.
+    #
+    # If group was already started added processes will also be started.
+    #
+    # @param process [Process, Array<Process>] New process or processes.
+    #
+    def <<(process)
+      Array(process).flatten.each do |process|
+        processes << process
+        # process.receiver = receiver
+
+        if started?
+          start process
+        end
+      end
+    end
+
+    # Start all process in group.
+    #
+    # Call blocks until all processes are started.
+    #
+    # @param opts [ Hash ] Options.
+    # @option opts [ Integer ] :delay Delay in seconds between starting processes.
+    #
+    def start(opts = {})
+      processes.each do |process|
+        unless process.started?
+          process.start
+          sleep opts[:delay] if opts[:delay]
+        end
+      end
+    end
+
+    # Check if group was already started.
+    #
+    # @return [ Boolean ] True if group was already started.
+    #
+    def started?
+      processes.any? &:started?
+    end
+
+    # Stop all processes.
+    #
+    def stop
+      processes.each do |process|
+        process.stop
+      end
+    end
+
+    # Wait until all process terminated.
+    #
+    # @param opts [ Hash ] Options.
+    # @option opts [ Integer ] :timeout Timeout in seconds to wait before
+    #   raising {Timeout::Error}.
+    #
+    def wait(opts = {})
+      opts[:timeout] ||= 30
+
+      ::Timeout::timeout(opts[:timeout]) do
+        processes.each{|p| p.wait}
+      end
+    end
+
+    # Start all process and wait for them to terminate.
+    #
+    # Given options will be passed to {#wait}.
+    #
+    # If timeout is given process will be terminated using {#stop}
+    # when timeout error is raised.
+    #
+    def run(opts = {})
+      start
+      wait opts
+    ensure
+      stop
+    end
+
+    # Check if group is alive e.g. if at least on process is alive.
+    #
+    # @return [ Boolean ] True if group is alive.
+    #
+    def alive?
+      processes.any? &:alive?
+    end
+
+    # Check if group is available. The group is available if all
+    # processes are available.
+    #
+    def available?
+      !processes.any?{|p| !p.available? }
+    end
+
+    # Wait until group is available. This implies waiting until
+    # all processes in group are available.
+    #
+    # Processes will not be stopped if timeout occurs.
+    #
+    # @param opts [ Hash ] Options.
+    # @option opts [ Integer ] :timeout Timeout in seconds to wait for processes
+    #   to become available. Defaults to {MultiProcess::DEFAULT_TIMEOUT}.
+    #
+    def available!(opts = {})
+      timeout = opts[:timeout] ? opts[:timeout].to_i : MultiProcess::DEFAULT_TIMEOUT
+
+      Timeout.timeout timeout do
+        processes.each{|p| p.available! }
+      end
+    end
+  end
+end

data/lib/multi_process/logger.rb

@@ -0,0 +1,71 @@
+module MultiProcess
+
+  # Can create pipes and multiplex pipe content to put into
+  # given IO objects e.g. multiple output from multiple
+  # processes to current stdout.
+  #
+  class Logger < Receiver
+
+    # Create new logger.
+    #
+    # @param out [IO] IO to push formatted output from
+    #   default created logger pipes.
+    # @param err [IO] IO to push formatted output from
+    #   error sources.
+    #
+    def initialize(*args)
+      @opts  = Hash === args.last ? args.pop : Hash.new
+      @out   = args[0] || $stdout
+      @err   = args[1] || $stderr
+
+      super()
+    end
+
+    protected
+
+    def received(process, name, line)
+      case name
+      when :err, :stderr
+        output process, line, io: @err, delimiter: 'E>'
+      when :out, :stdout
+        output process, line
+      when :sys
+        output(process, line, delimiter: '$>')# if @opts[:sys]
+      end
+    end
+
+    def read(pipe)
+      pipe.gets
+    end
+
+    private
+    def output(process, line, opts = {})
+      @mutex.synchronize do
+        opts[:delimiter]   ||= ' |'
+        name = if opts[:name]
+          opts[:name].to_s.dup
+        else
+          max = @readers.values.map{|h| h[:process] ? h[:process].title.length : 0 }.max
+          process ? process.title.to_s.rjust(max, ' ') : (' ' * max)
+        end
+
+        io = opts[:io] || @out
+        if @last_name == name
+          io.print " #{' ' * name.length} #{opts[:delimiter]} "
+        else
+          io.print " #{name} #{opts[:delimiter]} "
+        end
+        io.puts line
+        io.flush
+
+        @last_name = name
+      end
+    end
+
+    class << self
+      def global
+        @global ||= self.new $stdout, $stderr
+      end
+    end
+  end
+end

data/lib/multi_process/nil_receiver.rb

@@ -0,0 +1,13 @@
+module MultiProcess
+
+  # Receiver implementation that does nothing on every input.
+  #
+  class NilReceiver < Receiver
+
+    # Do nothing.
+    #
+    def received(process, name, message)
+      nil
+    end
+  end
+end

data/lib/multi_process/process.rb

@@ -0,0 +1,200 @@
+require 'active_support/core_ext/module/delegation'
+
+module MultiProcess
+
+  # Describes a single process that can be configured and run.
+  #
+  # {Process} basically is just a thin wrapper around {ChildProcess}.
+  #
+  class Process
+    #@!group Process
+
+    # Process title used in e.g. logger
+    attr_reader :title
+
+    # Command as full string.
+    attr_reader :command
+
+    # ChildProcess object.
+    attr_reader :childprocess
+
+    def initialize(*args)
+      args.flatten!
+      opts = (Hash === args.last ? args.pop : {})
+
+      @title        = opts[:title].to_s || args.first.to_s.strip.split(/\s+/, 2)[0]
+      @command      = args.map{ |arg| (arg =~ /\A[\s"']+\z/ ? arg.inspect : arg).gsub '"', '\"' }.join(' ')
+      @childprocess = create_childprocess *args
+
+      @env          = opts[:env] if Hash === opts[:env]
+      @env_clean    = opts[:clean_env].nil? ? true : !!opts[:clean_env]
+
+      self.receiver = MultiProcess::Logger.global
+
+      self.dir      = Dir.pwd
+      self.dir      = opts[:dir].to_s if opts[:dir]
+    end
+
+    # Delegate some methods to ChildProcess.
+    #
+    delegate :exited?, :alive?, :crashed?, :exit_code, :pid, to: :childprocess
+
+    # Wait until process finished.
+    #
+    # If no timeout is given it will wait definitely.
+    #
+    # @param opts [Hash] Options.
+    # @option opts [Integer] :timeout Timeout to wait in seconds.
+    #
+    def wait(opts = {})
+      if opts[:timeout]
+        childprocess.wait_for_exit opts[:timeout]
+      else
+        childprocess.wait
+      end
+    end
+
+    # Start process.
+    #
+    # Started processes will be stopped when ruby VM exists by hooking into
+    # `at_exit`.
+    #
+    def start
+      return false if started?
+
+      at_exit { stop }
+      receiver.message(self, :sys, self.command) if receiver
+      start_childprocess
+      @started = true
+    end
+
+    # Stop process.
+    #
+    # Will call `ChildProcess#stop`.
+    #
+    def stop(*args)
+      childprocess.stop *args if started?
+    end
+
+    # Check if server is available. What available means can be defined
+    # by subclasses e.g. a server process can check if server port is reachable.
+    #
+    # By default is process if available if alive? returns true.
+    #
+    def available?
+      alive?
+    end
+
+    # Wait until process is available. See {#available?}.
+    #
+    # @param opts [Hash] Options.
+    # @option opts [Integer] :timeout Timeout in seconds. Will raise
+    #  Timeout::Error if timeout is reached.
+    #
+    def available!(opts = {})
+      timeout = opts[:timeout] ? opts[:timeout].to_i : MultiProcess::DEFAULT_TIMEOUT
+
+      Timeout.timeout timeout do
+        sleep 0.2 until available?
+      end
+    rescue Timeout::Error => ex
+      raise Timeout::Error.new "Server #{id.inspect} on port #{port} didn't get up after #{timeout} seconds..."
+    end
+
+    # Check if process was started.
+    #
+    def started?
+      !!@started
+    end
+
+    # Start process and wait until it's finished.
+    #
+    # Given arguments will be passed to {#wait}.
+    #
+    def run(opts = {})
+      start
+      wait opts
+    end
+
+  #@!group Working Directory
+
+    # Working directory for child process.
+    attr_reader :dir
+
+    # Set process working directory. Only affect process if set before
+    # starting.
+    #
+    def dir=(dir)
+      @dir = ::File.expand_path(dir.to_s)
+      self.env['PWD'] = @dir
+    end
+
+    #@!group Environment
+
+    # Check if environment will be cleaned up for process.
+    #
+    # Currently that includes wrapping the process start in
+    # `Bundler.with_clean_env` to remove bundler environment
+    # variables.
+    #
+    def clean_env?
+      !!@env_clean
+    end
+
+    # Return current environment.
+    #
+    def env
+      @env ||= Hash.new
+    end
+
+    # Set environment.
+    #
+    def env=(env)
+      raise ArgumentError.new 'Environment must be a Hash.' unless hash === env
+      @env = env
+    end
+
+    #@!group Receiver
+
+    # Current receiver. Defaults to `MultiProcess::Logger.global`.
+    #
+    attr_reader :receiver
+
+    # Set receiver that should receive process output.
+    #
+    def receiver=(receiver)
+      if @receiver
+        childprocess.io.stdout.close
+        childprocess.io.stderr.close
+      end
+
+      childprocess.io.stdout = receiver.pipe(self, :out) if receiver
+      childprocess.io.stderr = receiver.pipe(self, :err) if receiver
+      @receiver = receiver
+    end
+
+    private
+
+    # Create child process.
+    #
+    def create_childprocess(*args)
+      ChildProcess.new *args.flatten
+    end
+
+    # Start child process.
+    #
+    # Can be used to hook in subclasses and modules.
+    #
+    def start_childprocess
+      env.each{|k, v| childprocess.environment[k.to_s] = v.to_s }
+
+      Dir.chdir(dir) do
+        if clean_env?
+          Bundler.with_clean_env { childprocess.start }
+        else
+          childprocess.start
+        end
+      end
+    end
+  end
+end