proclib 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6aa637a50487fd0311e29608e48813b41a7a9081
-  data.tar.gz: 89259efc574e1ba539de23f1f3ee7114b393ae72
+  metadata.gz: e65c3f6fff0184132ee293d9481f36307f033e50
+  data.tar.gz: dd211651a7ffe1b7a273223d05b939becb9933f0
 SHA512:
-  metadata.gz: 57c244222c681b1201f9596882daa27ddf59cff9fc2771bdc2d4304e6f04d7713b170ead9e976036276ec5c92a733383eb64f9b028ff7a6258572ccc546792ec
-  data.tar.gz: 82a4ef26e49c2ef1782bb2b1b74204e7c441d367f77956e9c1c6ac4697384e1220e98dabe5ec039b9abf9d6cbfdf62df9ac88fb4ffbedc510a830a82c295cfe8
+  metadata.gz: a6c87b7026897592f982245ec772b7329a81eb91e2239816231dee82d351f49379866599504c6efffb4fbfc790907f99a2b26f812cbb8a50ac7e7dce6d7cd627
+  data.tar.gz: 365c9d78bfed861ec49d8c8c86908cf766c553e224a44090144c0afad16f75869b579cf04193a6feb68c3a62b50dc1086d8717f29ff6cd36aeb2aa4f28c71aaa

data/README.md

@@ -8,16 +8,26 @@ I use Proclib as a suport library for a couple of systems utilities that I'm
 slowly preparing for a proper open-source release.  Proclib is one of
 several extracted libraries that I'll be maturing into their own projects.
 
-Proclib is currently beta quality at best.
+**Disclaimer**
+
+Proclib is currently beta quality at best. The code is written in a
+fairly unmaintainable fashion at the moment, and I definitely don't
+suggest anyone not interested in putting some work into the library
+use this in its current state.
 
 ## Usage
 
-See `examples/main.rb`
+See acceptance specs in `spec/acceptance`.
 
 Currenty, Proclib doesn't do anything on exit to kill child processes, so you'll
 need to trap the appropriate signals yourself to keep from leaving orphaned processes
 around.
 
+## Issues
+
+- Even when caching output, Proclib expects short lines meant for user consumption
+  in output from its processes, and will crash on more than a few KB per line.
+
 ## License
 
 [MIT License](http://opensource.org/licenses/MIT).

data/lib/proclib.rb

@@ -1,53 +1,33 @@
-require 'open3'
-require 'thread'
-
 require 'proclib/version'
-
-require 'proclib/event_emitter'
-require 'proclib/process'
-require 'proclib/process_group'
 require 'proclib/executor'
+require 'proclib/invocation'
 
 module Proclib
-  module Methods
-    def run(cmd,
-      tag: nil,
-      log_to_console: false,
-      capture_output: true,
-      env: {},
-      on_output: nil,
-      cwd: nil
-    )
-
-      raise(ArgumentError, "env must be a Hash") unless env.kind_of?(Hash)
-
-      runnable = if cmd.kind_of? String
-         Process.new(cmd, tag: tag || cmd[0..20], env: env, run_dir: cwd)
-      elsif cmd.kind_of?(Hash)
-        processes = cmd.map do |(k,v)|
-          Process.new(v, tag: k || v[0..20], env: env, run_dir: cwd)
-        end
-
-        ProcessGroup.new(processes)
-      else
-        raise ArgumentError, "Unexpected type for `cmd`: #{cmd.class}.  \n"\
-          "Expected String or Hash"
-      end
-
-      unless on_output.nil? || on_output.kind_of?(Proc) || on_ouptut.kind_of?(Lambda)
-        raise ArgumentError, "Expected :on_output to be a proc or lambda if given"
-      end
-
-      executor = Executor.new(runnable,
-        log_to_console: log_to_console,
-        on_output: on_output,
-        cache_output: capture_output)
-
-      executor.run_sync
+  def self.run(cmd,
+    tag: nil,
+    log_to_console: false,
+    capture_output: true,
+    env: {},
+    on_output: nil,
+    cwd: nil,
+    ssh: nil
+  )
+
+    inv = Invocation.new(cmd,
+      tag: tag,
+      env: env,
+      cwd: cwd,
+      ssh: ssh)
+
+    executor = Executor.new(inv.commands,
+      log_to_console: log_to_console,
+      cache_output: capture_output
+    ).tap do |ex|
+      ex.on_output(&on_output) unless on_output.nil?
     end
-  end
 
-  class << self
-    include Methods
+    executor.run_sync
+  rescue Invocation::Invalid => e
+    raise ArgumentError, e.message
   end
 end

data/lib/proclib/channel.rb

@@ -0,0 +1,44 @@
+require 'thread'
+
+module Proclib
+  # Simple thread-safe communication mechanism
+  class Channel
+    include Enumerable
+
+    Message = Struct.new(:type, :data)
+    UnexpectedMessageType = Class.new(StandardError)
+
+    attr_reader :allowed_types
+
+    def initialize(*types)
+      @allowed_types = types
+    end
+
+    def emit(type, data = nil)
+      unless allowed_types.include?(type)
+        raise UnexpectedMessageType,
+          "Message type expected to be one of `#{allowed_types}`.  "\
+            "Got: `#{type}`"
+      end
+
+      queue.push(Message.new(type, data))
+    end
+
+    def close
+      queue.push(:done)
+    end
+
+    def each
+      raise(ArgumentError, 'Block Expected!') unless block_given?
+
+      while msg = queue.pop
+        break if msg == :done
+        yield msg
+      end
+    end
+
+    def queue
+      @queue ||= Queue.new
+    end
+  end
+end

data/lib/proclib/command.rb

@@ -0,0 +1,129 @@
+require 'open3'
+require 'ostruct'
+
+require 'proclib/errors'
+
+require 'net/ssh'
+
+module Proclib
+  module Commands
+    class Command
+      NotYetRunning = Class.new(Error)
+      NotYetTerminated = Class.new(Error)
+
+      attr_reader :tag, :cmdline, :env, :run_dir
+
+      def initialize(tag: nil, cmdline:, env: {} , run_dir: nil)
+        @env = env.map {|k,v| [k.to_s, v.to_s]}.to_h
+        @cmdline = cmdline
+        @tag = tag || cmdline[0..20]
+        @run_dir = run_dir
+      end
+
+      def pipes
+        @pipes ||= OpenStruct.new
+      end
+
+      def spawn
+        raise NotImplementedError
+      end
+
+      def wait
+        raise NotImplementedError
+      end
+
+      def result
+        @result || raise(NotYetTerminated)
+      end
+    end
+    private_constant :Command
+
+    class LocalCommand < Command
+      def spawn
+        spawn = -> do
+          pipes.stdin, pipes.stdout, pipes.stderr, @wait_thread = Open3.popen3(env, cmdline)
+        end
+
+        if run_dir
+          Dir.chdir(run_dir) { spawn.call }
+        else
+          spawn.call
+        end
+      end
+
+      def wait
+        @result ||= wait_thread.value.to_i
+      end
+
+      private
+
+      def wait_thread
+        @wait_thread || raise(NotYetRunning)
+      end
+    end
+
+    class SshCommand < Command
+      attr_reader :ssh_opts
+
+      SSHError = Class.new(Error)
+
+      def initialize(ssh:, **args)
+        @ssh_opts = ssh.clone
+        super(**args)
+      end
+
+      def spawn
+        write_pipes
+
+        open_channel do |ch|
+          ch.exec(cmdline) do |_, success|
+            raise SSHError, "Command Failed" unless success
+          end
+        end
+      end
+
+      def wait
+        ssh_session.loop
+      end
+
+      private
+
+      def open_channel
+         ssh_session.open_channel do |channel|
+          channel.on_open_failed do |ch, code, desc, lang|
+            raise SSHError, desc
+          end
+
+          channel.on_data {|_, data| write_pipes[:stdout].write(data) }
+
+          channel.on_extended_data {|_, data| write_pipes[:stderr].write(data) }
+
+          channel.on_request("exit-status") do |_, data|
+            write_pipes.each {|k,v| v.close }
+            @result = data.read_long
+          end
+
+          yield channel
+        end
+      end
+
+      def write_pipes
+        @write_pipes ||= %i(stdout stderr).map do |type|
+          read, write = IO.pipe
+          pipes[type] = read
+          [type, write]
+        end.to_h
+      end
+
+      def ssh_session
+        @ssh_session ||= Net::SSH.start(*ssh_params, ssh_opts).tap do |session|
+          session.chdir(run_dir) unless run_dir.nil?
+        end
+      end
+
+      def ssh_params
+        %i(host user).map {|i| ssh_opts.delete(i)}.compact
+      end
+    end
+  end
+end

data/lib/proclib/command_monitor.rb

@@ -0,0 +1,29 @@
+require 'proclib/output_handler'
+
+module Proclib
+  # Watches the given command, emitting the appropriate events
+  # on the given channel when the command does something
+  class CommandMonitor
+    attr_reader :command, :channel
+
+    def initialize(command, channel:)
+      @command, @channel = command, channel
+    end
+
+    def start
+      io_handlers.each(&:start)
+    end
+
+    def wait
+      io_handlers.each(&:wait)
+    end
+
+    private
+
+    def io_handlers
+      @io_handlers ||= %i(stderr stdout).map do |type|
+         OutputHandler.new(type, command, channel: channel)
+      end
+    end
+  end
+end

data/lib/proclib/errors.rb

@@ -0,0 +1,3 @@
+module Proclib
+  Error = Class.new(StandardError)
+end

data/lib/proclib/executor.rb

@@ -1,52 +1,83 @@
-require 'proclib/event_emitter'
 require 'proclib/loggers/console'
 require 'proclib/output_cache'
+require 'proclib/channel'
+require 'proclib/process'
+require 'proclib/result'
 
 module Proclib
-  # Runs a runnable, handling emitted events and dispatching to configured
-  # facilities
+  # Runs a list of commands simultaenously, providing callbacks on their output
+  # lines and exits, as well as optional output logging and caching.
   class Executor
-    attr_reader :opts
+    attr_reader :log_to_console, :cache_output, :commands, :callbacks
+    alias_method :log_to_console?, :log_to_console
+    alias_method :cache_output?, :cache_output
 
-    def initialize(runnable, opts = {})
-      @runnable = runnable
-      @opts = opts
+    def initialize(commands, log_to_console: false, cache_output: false)
+      @commands, @log_to_console, @cache_output =
+        commands, log_to_console, cache_output
+      @callbacks = Struct.new(:exit, :output).new([], [])
     end
 
-    def on(name, &block)
-      channel.on(name, &block)
+    def run_sync
+      start
+      wait
     end
 
-    def run_sync
-      configure
-      runnable.spawn
-      channel.watch
-      return @status, *%i{stdout stderr}.map {|i| output_cache.pipe_aggregate(i) }
+    def start
+      processes.each(&:spawn)
+    end
+
+    def wait
+      channel.each do |message|
+        handle_exit(message) if message.type == :exit
+        handle_output(message) if message.type == :output
+      end
+
+      result
+    end
+
+    def on_exit(&blk)
+      callbacks.exit << blk
+    end
+
+    def on_output(&blk)
+      callbacks.output << blk
+    end
+
+    def exit_states
+      @exit_states ||= Array.new
     end
 
     private
 
-    attr_reader :runnable, :log_to_console
+    def result
+      Result.new(
+        exit_code: aggregate_exit_code,
+        output_cache: (output_cache if cache_output?)
+      )
+    end
 
-    def configure
-      runnable.bind_to(channel)
-      channel.on(:exit) do |event|
-        @status = event.data.to_i
-        channel.finalize
+    def aggregate_exit_code
+      if exit_states.all? {|c| c == 0}
+        0
+      elsif exit_states.size == 1
+        exit_states.first
+      else
+        1
       end
-      configure_output
     end
 
-    def configure_output
-      channel.on(:output) {|e| console_logger << e.data } if opts[:log_to_console]
-      channel.on(:output) {|e| output_cache << e.data} if opts[:cache_output]
+    def handle_exit(message)
+      exit_states << message.data
+      channel.close if exit_states.size == processes.size
+      callbacks.exit.each {|c| c[message.data] }
+    end
 
-      if opts[:on_output]
-        channel.on(:output) do |e|
-          msg = e.data
-          opts[:on_output].call(msg.line, msg.process_tag, msg.pipe_name)
-        end
-      end
+    def handle_output(message)
+      callbacks.output.each {|c| c[message.data]}
+
+      console_logger << message.data  if log_to_console?
+      output_cache << message.data if cache_output?
     end
 
     def output_cache
@@ -58,7 +89,11 @@ module Proclib
     end
 
     def channel
-      @channel ||= EventEmitter::Channel.new
+      @channel ||= Channel.new(:output, :exit)
+    end
+
+    def processes
+      commands.map {|c| Process.new(c, channel: channel) }
     end
   end
 end

data/lib/proclib/invocation.rb

@@ -0,0 +1,116 @@
+require 'pathname'
+
+require 'proclib/errors'
+require 'proclib/command'
+
+module Proclib
+  class Invocation
+    Invalid = Class.new(Error)
+
+    def initialize(cmd,
+      tag: nil,
+      env: {},
+      cwd: nil,
+      ssh: nil
+    )
+      @cmd = cmd
+      @tag = tag
+      @env = env
+      @cwd = cwd
+      @ssh = ssh
+    end
+
+    def commands
+      if validated_cmd.is_a?(String)
+        [ make_command(validated_cmd) ]
+      else
+        validated_cmd.map do |tag, cmdline|
+          make_command(cmdline, tag: tag)
+        end
+      end
+    end
+
+    private
+
+    def make_command(cmdline, tag: nil)
+      command_class.new(**command_args)
+    end
+
+    def command_args
+      @command_args ||= {
+        tag: @tag,
+        env: validated_env,
+        run_dir: validated_cwd,
+        cmdline: validated_cmd
+      }.tap do |args|
+        args[:ssh] = validated_ssh if !validated_ssh.nil?
+      end
+    end
+
+    def command_class
+      if validated_ssh.nil?
+        Commands::LocalCommand
+      else
+        Commands::SshCommand
+      end
+    end
+
+    def validated_env
+      if !@env.kind_of?(Hash)
+        raise Invalid, "`env` must be a Hash if given"
+      end
+
+      @env.each do |*args|
+        args.each do |v|
+          unless [String, Symbol].any? {|c| v.kind_of?(c) }
+            raise Invalid "`env` must be a hash in the form of "\
+              "[String|Symbol] => [String|Symbol] if given"
+          end
+        end
+      end
+    end
+
+    def validated_cwd
+      return nil if @cwd.nil?
+
+      @validated_cwd ||= @cwd.tap do |cwd|
+        unless [Pathname, String].any? {|c| cwd.kind_of?(c) }
+          raise Invalid, "`cwd` must be a Pathname or String if given"
+        end
+      end
+    end
+
+    def validated_ssh
+      return if @ssh.nil?
+
+      @validated_ssh ||= begin
+        %i(host user).each do |k|
+          if @ssh[k].nil?
+            raise Invalid, ":ssh options must contain key `#{k}` if given"
+          end
+        end
+
+        @validated_ssh
+      end
+    end
+
+    def validated_cmd
+      @validated_cmd ||= begin
+        if ![String, Hash].any?{|c| @cmd.kind_of?(c)}
+          raise Invalid, "Expected cmd to be either a String or a Hash"
+        end
+
+        if @cmd.kind_of?(Hash)
+          @cmd.each do |key, value|
+            if ! [String, Symbol].include?(key) or !value.kind_of?(String)
+              raise Invalid, "If cmd is a list of commands it must be in "\
+                "the form of `[String|Symbol] => String`"
+            end
+          end
+        end
+
+        @cmd
+      end
+    end
+  end
+end

data/lib/proclib/output_handler.rb

@@ -1,14 +1,54 @@
 require 'thread'
+require 'proclib/errors'
 
 module Proclib
   # Emits events for the given io pipe with relevant tagging info
   class OutputHandler
-    Message = Class.new(Struct.new(:process_tag, :pipe_name, :line))
+    # Calls its given callback with each line in the input written
+    # to the buffer
+    class LineBuffer
+      NEWLINE = "\n"
+      MAX_SIZE = 1024 * 10
+      SIZE_ERROR_MESSAGE = "A line of greater than #{MAX_SIZE} bytes was " \
+        "encountered from a process."
+
+      MaxSizeExceeded = Class.new(Error)
+
+      def initialize(&blk)
+        @buf = String.new
+        @callback = blk
+      end
+
+      def write(str)
+        buf << str
+
+        while buf.include?(NEWLINE)
+          idx = buf.index(NEWLINE)
+          callback.call(buf[0..(idx - 1)] + NEWLINE)
+          self.buf = (buf[(idx + 1)..-1] || String.new)
+        end
+
+        if buf.bytesize > MAX_SIZE
+          raise MaxSizeExceeded, SIZE_ERROR_MESSAGE
+        end
+      end
+
+      def flush
+        callback.call(buf + "\n") unless buf.empty?
+      end
 
-    include EventEmitter::Producer
+      private
 
-    def initialize(process_tag, pipe_name, pipe)
-      @process_tag, @pipe_name, @pipe = process_tag, pipe_name, pipe
+      attr_accessor :buf
+      attr_reader :callback
+    end
+
+    READ_SIZE = 1024
+    Message = Class.new(Struct.new(:process_tag, :pipe_name, :line))
+
+    attr_reader :type, :command, :channel
+    def initialize(type, command, channel:)
+      @type, @command, @channel = type, command, channel
     end
 
     def start
@@ -25,13 +65,22 @@ module Proclib
 
     private
 
-    attr_reader :process_tag, :pipe_name, :pipe
+    def pipe
+      @pipe ||= command.pipes[type]
+    end
 
     def monitor
-      pipe.each_line do |line|
-        emit(:output, Message.new(process_tag, pipe_name, line))
+      while s = pipe.read(READ_SIZE)
+        line_buffer.write(s)
+      end
+
+      line_buffer.flush
+    end
+
+    def line_buffer
+      @line_buffer ||= LineBuffer.new do |line|
+        channel.emit(:output, Message.new(command.tag, type, line))
       end
-      emit(:end_of_output)
     end
   end
 end

data/lib/proclib/process.rb

@@ -1,82 +1,42 @@
-require 'open3'
-require 'ostruct'
+require 'thread'
 
-require 'proclib/output_handler'
+require 'proclib/command_monitor'
 
 module Proclib
-  # Runs a single process, emitting output, state changes and exit status
+  # Runs a command, emitting output, state changes and
+  # exit status to the given channel
   class Process
-    include EventEmitter::Producer
-
-    attr_reader :cmdline, :tag, :env, :run_dir
+    attr_reader :command, :channel
 
     Error = Class.new(StandardError)
 
-    def initialize(cmdline, tag:, env: {}, run_dir: nil)
-      @cmdline = cmdline
-      @tag = tag
-      @env = env.map {|k,v| [k.to_s, v.to_s]}.to_h
-      @state = :ready
-      @io_handlers = OpenStruct.new
-      @pipes = OpenStruct.new
-      @run_dir = run_dir
+    def initialize(command, channel:)
+      @command, @channel, @state = command, channel, :ready
     end
 
     def spawn
-      raise(Error, "Already started process") unless @wait_thread.nil?
-
-      spawn = -> do
-        pipes.stdin, pipes.stdout, pipes.stderr, @wait_thread = Open3.popen3(env, cmdline)
-      end
+      raise(Error, "Already started process") if @state != :ready
 
-      if run_dir
-        Dir.chdir(run_dir) { spawn.call }
-      else
-        spawn.call
-      end
+      @state = :started
+      command.spawn
 
-      @state = :running?
-      start_output_emitters
+      output_emitter.start
       start_watch_thread
     end
 
-    def complete?
-      @state == :complete
-    end
-
     private
-    attr_reader :wait_thread, :io_handlers, :pipes
+    attr_reader :wait_thread, :io_handlers
 
     def start_watch_thread
-      Thread.new do
-        result = wait_thread.value
-        io_handlers.each_pair {|(_, e)| e.wait }
-        @state = :complete
-        emit(:exit, result)
-        emit(:complete)
+      @watch_thread ||= Thread.new do
+        command.wait
+        output_emitter.wait
+        channel.emit(:exit, command.result)
       end
     end
 
-    def start_output_emitters
-      %i(stderr stdout).map do |type|
-        io_handlers[type] = OutputHandler.new(tag, type, pipes[type]).tap do |handler|
-          bubble_events_for(handler)
-          handler.start
-        end
-      end
-    end
-
-    def check_started
-      if wait_thread.nil?
-        raise Error, "Process `#{tag}` is not yet started!"
-      end
-    end
-
-    def output_buffer
-      check_started
-      @output_buffer ||= OutputBuffer.new(tag, stdout_pipe, stderr_pipe).tap do |buffer|
-        bubble_events_for(buffer)
-      end
+    def output_emitter
+      @output_emitter ||= CommandMonitor.new(command, channel: channel)
     end
   end
   private_constant :Process

data/lib/proclib/result.rb

@@ -0,0 +1,31 @@
+require 'proclib/errors'
+
+module Proclib
+  class Result
+    OutputNotAvailable = Class.new(Error)
+
+    attr_reader :exit_code
+    def initialize(exit_code:, output_cache: nil)
+      @exit_code, @output_cache = exit_code, output_cache
+    end
+
+    %i(stdin stdout).each do |type|
+      define_method(type) do
+        if @output_cache.nil?
+          raise OutputNotAvailable, "`#{type}` not cached for this process. "\
+            "ensure output caching is enabled when invoking."
+        end
+
+        @output_cache.pipe_aggregate(type)
+      end
+    end
+
+    def success?
+      exit_code == 0
+    end
+
+    def failure?
+      !success?
+    end
+  end
+end

data/lib/proclib/version.rb

@@ -1,3 +1,3 @@
 module Proclib
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/proclib.gemspec

@@ -22,8 +22,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "net-ssh", "~> 4.2"
+
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "docker-api", "~> 1.0"
   spec.add_development_dependency "pry"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: proclib
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Jack Forrest
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-02 00:00:00.000000000 Z
+date: 2018-01-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -85,15 +113,19 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- examples/main.rb
 - lib/proclib.rb
-- lib/proclib/event_emitter.rb
+- lib/proclib/channel.rb
+- lib/proclib/command.rb
+- lib/proclib/command_monitor.rb
+- lib/proclib/errors.rb
 - lib/proclib/executor.rb
+- lib/proclib/invocation.rb
 - lib/proclib/loggers/console.rb
 - lib/proclib/output_cache.rb
 - lib/proclib/output_handler.rb
 - lib/proclib/process.rb
 - lib/proclib/process_group.rb
+- lib/proclib/result.rb
 - lib/proclib/string_formatting.rb
 - lib/proclib/version.rb
 - proclib.gemspec

data/examples/main.rb

@@ -1,31 +0,0 @@
-require 'pry'
-require 'pathname'
-
-Thread.abort_on_exception = true
-
-$LOAD_PATH.unshift Pathname.new(File.expand_path(__FILE__)).join('..', '..', 'lib').to_s
-
-require_relative '../lib/proclib'
-
-# Run a quick command with output logged to the console
-
-Proclib.run("echo herorooo >&2", tag: :test, log_to_console: true)
-
-# Pass env vars to subprocess
-
-Proclib.run("echo $FOO", env: {FOO: 'hi'}, log_to_console: true)
-
-_, stdout, _ = Proclib.run("ls /tmp/", capture_output: true)
-
-puts "Files in /tmp"
-puts stdout.join
-
-cmd = "seq 1 5 | while read n; do echo $n; sleep 0.5; done"
-
-Proclib.run({one: cmd, two: cmd}, log_to_console: true)
-
-output_callback = -> (line, tag, pipe_name) {
-  STDOUT.printf("%s:%s:%s", tag, pipe_name, line)
-}
-
-Proclib.run(cmd, tag: :count_things, on_output: output_callback)

data/lib/proclib/event_emitter.rb

@@ -1,71 +0,0 @@
-module Proclib
-  # Async event utils
-  module EventEmitter
-    Event = Struct.new(:name, :sender, :data)
-    Error = Class.new(StandardError)
-
-    # Provides callbacks on events from bound producers
-    class Channel
-      COMPLETE = Object.new
-
-      def initialize
-        @queue = ::Queue.new
-        @handlers = Hash.new
-      end
-
-      def push(msg)
-        unless msg.kind_of?(Event)
-          raise(Error, "EventEmitter::Queue should only handle messages of type EventEmitter::Event")
-        end
-
-        @queue.push(msg)
-      end
-
-      def on(name, &handler)
-        (handlers[name] ||= Array.new) << handler
-      end
-
-      def watch
-        while ev = @queue.pop
-          break if ev == COMPLETE
-          handlers[ev.name].each {|h| h.call(ev)} if handlers[ev.name]
-        end
-      end
-
-      def finalize
-        @queue.push(COMPLETE)
-      end
-
-      private
-      attr_reader :handlers
-    end
-
-    # Emits messages to bound channel
-    module Producer
-      def bind_to(queue)
-        @event_queue = queue
-      end
-
-      def bound?
-        ! @event_queue.nil?
-      end
-
-      private
-
-      def bubble_events_for(child)
-        if bound?
-          child.bind_to(@event_queue)
-        end
-      end
-
-      def emit(name, data = nil)
-        push(Event.new(name, self, data))
-      end
-
-      def push(event)
-        @event_queue.push(event) if bound?
-      end
-    end
-  end
-  private_constant :EventEmitter
-end