em-process-buffer 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+tmp
+pkg

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+ruby '1.9.3'
+
+# Specify your gem's dependencies in gem.gemspec
+gemspec
+
+
+gem 'eventmachine', git: 'https://github.com/eventmachine/eventmachine'
+gem 'posix-spawn', '0.3.6'

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GIT
+  remote: https://github.com/eventmachine/eventmachine
+  revision: 9473a1b181ed1997e3156d960b2bb2783f508191
+  specs:
+    eventmachine (1.0.0.rc.4)
+
+PATH
+  remote: .
+  specs:
+    em-process-buffer (0.0.1)
+      eventmachine (~> 1.0.0.rc.4)
+      posix-spawn (~> 0.3.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    posix-spawn (0.3.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-process-buffer!
+  eventmachine!
+  posix-spawn (= 0.3.6)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dave Newman
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,28 @@
+# EM Process Buffer
+
+A restartable process watcher that buffers STDIN and STDOUT.
+
+This is designed to watch long running processes. The watching process can be independently restarted without killing the watched process. In the mean time STDOUT is buffered in memory until the watching process is restarted so no output is missed.
+
+Creates named pipes on disk for STDIN and STDOUT.
+
+QUIT will gracefully stop the watching process. TERM will kill the watcher and the buffered process.
+
+## Example
+
+	# In terminal 1 start the process and watcher
+	$ ruby examples/simple.rb
+	watcher started pid=7652
+	process started pid=7815
+	[7815] [STDIN 0.0] hello
+	[7815] [STDIN 0.99] hello
+	
+	# In terminal 2 kill the watcher
+	$ kill 7652
+	
+	# back in terminal 1 restart the watcher
+	$ ruby examples/simple.rb
+	watcher started pid=8418
+	found running process pid=7869 pid_file=tmp/simple.pid
+	[7869] [STDIN 5.34] hello
+	[7869] [STDIN 6.84] hello

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/buffer-process

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'posix/spawn'
+
+module Process
+  def self.alive?(pid)
+    begin
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+
+  def self.child command
+    POSIX::Spawn::Child.new command
+  end
+end
+
+class IOBuffer
+  def buffer
+    @buffer ||= []
+  end
+
+  def tick
+    # puts "[#{Process.pid}] [#{self.class.name}] tick"
+
+    if IO.select([io_in], nil, nil, 0.5)
+      begin
+        incoming = io_in.read_nonblock 1024
+        # p incoming
+        if incoming
+          buffer << incoming
+        end
+      rescue EOFError
+      end
+    end
+
+    begin
+      item = nil
+      while buffer.any?
+        item = buffer.shift
+        io_out.write item
+      end
+    rescue Errno::EPIPE
+      buffer.unshift item
+    end
+  end
+end
+
+class IOBufferIn < IOBuffer
+  # named_pipe > IO
+
+  attr_reader :io_out
+
+  def initialize pipe_in_file, io_out
+    @pipe_in_file, @io_out = pipe_in_file, io_out
+    io_out.sync = true
+
+    system "mkfifo #{@pipe_in_file}"
+  end
+
+  def io_in
+    @io_in ||= File.open(@pipe_in_file, File::NONBLOCK + File::RDONLY)
+  end
+
+  def cleanup
+    @io_in.close if @io_in
+    system "rm -f #{@pipe_in_file}"
+  end
+end
+
+class IOBufferOut < IOBuffer
+  # IO > named pipe
+
+  attr_reader :io_in
+  attr_reader :io_out
+
+  def initialize io_in, pipe_out_file
+    @pipe_out_file, @io_in = pipe_out_file, io_in
+
+    system "mkfifo #{@pipe_out_file}"
+  end
+
+  def io_out
+    @io_out ||= begin
+      io_out = File.open(@pipe_out_file, 'w+')
+      io_out.sync = true
+      io_out
+    end
+  end
+
+  def cleanup
+    @io_out.close if @io_out
+    system "rm -f #{@pipe_out_file}"
+  end
+end
+
+
+pipe_directory = working_directory = Process.child('pwd').out.strip
+pid_file = nil
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [-d pipe_directory] [-C working_directory] [-p pid_file] command"
+
+  opts.separator ""
+  opts.on("-d", "--directory directory", "pipe directory") { |dir|
+    pipe_directory = File.expand_path(dir)
+  }
+  opts.on("-C", "--directory directory", "working directory") { |dir|
+    working_directory = File.expand_path(dir)
+  }
+  opts.on("-p", "--pid pid_file", "pid file") { |file|
+    pid_file = File.expand_path(file)
+  }
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    abort
+  end
+end
+
+opts.parse!(ARGV)
+
+command = ARGV.first
+
+pipe_stdin_file, pipe_stdout_file = "#{pipe_directory}/pipe_stdin",  "#{pipe_directory}/pipe_stdout"
+
+pid, children, stdin_buffer, stdout_buffer = nil, nil, nil, nil
+
+begin
+  Dir.chdir(working_directory) do
+    pid, stdin, stdout = POSIX::Spawn::popen4("exec #{command} 2>&1")
+
+    File.write(pid_file, pid) if pid_file
+    puts "process started with pid=#{pid}"
+
+    stdin_buffer = IOBufferIn.new(pipe_stdin_file, stdin)
+    stdout_buffer = IOBufferOut.new(stdout, pipe_stdout_file)
+
+    loop do
+      stdout_buffer.tick
+      stdin_buffer.tick
+
+      if Process.waitpid(pid, Process::WNOHANG)
+        puts "process exited pid=#{pid}"
+        break
+      end
+    end
+  end
+ensure
+  puts "cleaning up"
+  stdin_buffer.cleanup if stdin_buffer
+  stdout_buffer.cleanup if stdout_buffer
+
+  Process.child "rm -f #{pid_file}" if pid_file
+end

data/em-process-buffer.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eventmachine/process_buffer/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "em-process-buffer"
+  gem.version       = EM::ProcessBuffer::VERSION
+  gem.authors       = ["Dave Newman"]
+  gem.email         = ["dave@whatupdave.com"]
+  gem.description   = %q{A restartable process watcher that buffers STDIN and STDOUT}
+  gem.summary       = %q{A restartable process watcher that buffers STDIN and STDOUT}
+  gem.homepage      = "https://github.com/minefold/em-process-buffer"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = %w(bin lib)
+  
+  gem.add_dependency "eventmachine", "~>1.0.0.rc.4"
+  gem.add_dependency "posix-spawn", "~>0.3.6"
+end

data/examples/in-out

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+i = 0
+started_at = Time.now
+while true
+  puts "[STDIN #{(Time.now - started_at).round(2)}] #{gets}"
+  i += 1
+end

data/examples/simple.rb

@@ -0,0 +1,32 @@
+$:.unshift File.join(__FILE__, '../../lib')
+
+require 'eventmachine'
+require 'eventmachine/process_buffer'
+require 'eventmachine/profile'
+
+module Watcher
+  def post_init
+    started_at = Time.now
+    EM.add_periodic_timer(1) do
+      send_stdin 'hello'
+    end
+  end
+
+  def process_started
+    puts "process started pid=#{pid}"
+  end
+
+  def process_exited
+    puts "process exited pid=#{pid}"
+  end
+
+  def receive_stdout line
+    puts "[#{pid}] #{line}"
+  end
+end
+
+EM.run do
+  puts "watcher started pid=#{Process.pid}"
+  cmd = File.join(File.expand_path(File.dirname(__FILE__)), 'in-out')
+  EM.buffer_process 'tmp/simple.pid', 'tmp/simple', cmd, {}, Watcher
+end

data/examples/timer.rb

@@ -0,0 +1,6 @@
+require 'eventmachine'
+
+
+EM.run do
+  EM.profile
+end

data/lib/core_ext/process.rb

@@ -0,0 +1,10 @@
+module Process
+  def self.alive?(pid)
+    begin
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/eventmachine/line_processor.rb

@@ -0,0 +1,13 @@
+module EM
+  class LineProcessor < EM::P::LineAndTextProtocol
+    attr_accessor :on_line
+
+    def receive_line(line)
+      if on_line
+        EM.next_tick do
+          on_line.call line
+        end
+      end
+    end
+  end
+end

data/lib/eventmachine/pid_poller.rb

@@ -0,0 +1,22 @@
+module EM
+  module PidPoller
+    def self.on_exit pid, *a, &b
+      cb = EM::Callback *a, &b
+      poller = EM.add_periodic_timer(1) do
+        state = process_alive?(pid)
+        unless state
+          poller.cancel
+          cb.call
+        end
+      end
+      cb
+    end
+
+    def self.process_alive? pid
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/eventmachine/process_buffer.rb

@@ -0,0 +1,85 @@
+require "bundler/setup"
+
+require 'posix/spawn'
+require 'core_ext/process'
+require 'eventmachine/pid_poller'
+require 'eventmachine/line_processor'
+require 'eventmachine/process_buffer/watcher'
+
+module EM
+  module ProcessBuffer
+    BIN = File.expand_path File.join(__FILE__, '../../../bin')
+    
+    def self.spawn_detached cmd, environment = {}
+      begin
+        pid, stdin, stdout, stderr = POSIX::Spawn::popen4(environment, cmd)
+        Process.detach pid
+        return pid, stdin, stdout, stderr
+      rescue Errno::EAGAIN # Resource temporarily unavailable
+        retry
+      end
+    end
+    
+    def self.start_process pipe_directory, working_directory, pid_file, command, environment, handler, *args, &block
+      buffer_command = %Q{#{BIN}/buffer-process -d #{pipe_directory} -C #{working_directory} -p #{pid_file} "#{command}"}
+      buffer_pid, stdin, stdout, stderr = spawn_detached buffer_command, environment
+      Process.detach buffer_pid
+
+      wait = EM.add_periodic_timer(0.5) do
+        begin
+          if Process.waitpid(buffer_pid, Process::WNOHANG)
+            stdin.close
+            stdout.gets
+            wait.cancel
+
+            puts "process exited pid=#{buffer_pid}"
+
+          elsif File.exist?(pid_file)
+            stdin.close
+            stdout.gets
+            wait.cancel
+
+            c = Class.new(EM::ProcessBuffer::Watcher) { include handler }
+            watcher = c.new pid_file, pipe_directory, working_directory, *args
+            
+            watcher.process_started
+            watcher.attach_to_process
+            
+            block.call watcher if block_given?
+          end
+        rescue Errno::ECHILD
+          # waiting...
+        end
+      end
+    end
+
+    def self.attach_to_process pid, pipe_directory, working_directory, pid_file, command, handler, *args
+      c = Class.new(EM::ProcessBuffer::Watcher) { include handler }
+      watcher = c.new pid_file, pipe_directory, working_directory, *args
+      watcher.attach_to_process
+      watcher.process_reattached
+
+      yield watcher if block_given?
+    end
+  end
+
+  def self.buffer_process pid_file, working_directory, command, environment, handler, *args, &block
+    pipe_directory = working_directory
+    
+    FileUtils.mkdir_p working_directory
+
+    if File.exist?(pid_file)
+      pid = File.read(pid_file).strip.to_i
+
+      if Process.alive?(pid)
+        puts "found running process pid=#{pid} pid_file=#{pid_file}"
+        ProcessBuffer.attach_to_process pid, pipe_directory, working_directory, pid_file, command, handler, *args, &block
+      else
+        puts "found dead process pid=#{pid} pid_file=#{pid_file}"
+        ProcessBuffer.start_process pipe_directory, working_directory, pid_file, command, environment, handler, *args, &block
+      end
+    else
+      ProcessBuffer.start_process pipe_directory, working_directory, pid_file, command, environment, handler, *args, &block
+    end
+  end
+end

data/lib/eventmachine/process_buffer/version.rb

@@ -0,0 +1,5 @@
+module EM
+  module ProcessBuffer
+    VERSION = "0.0.2"
+  end
+end

data/lib/eventmachine/process_buffer/watcher.rb

@@ -0,0 +1,60 @@
+module EM
+  module ProcessBuffer
+
+    class Watcher
+      attr_reader :pid, :pid_file, :pipe_directory, :working_directory
+
+      def initialize pid_file, pipe_directory, working_directory, *args
+        @pid_file = pid_file
+        @pipe_directory = pipe_directory
+        @working_directory = working_directory
+        @pid = File.read(pid_file).strip.to_i
+      end
+
+      def post_init
+      end
+
+      def receive_stdout line
+        puts ">> #{line}"
+      end
+
+      def process_started
+        puts "watched process started"
+      end
+
+      def process_watched
+      end
+
+      def process_exited
+        puts "watched process exited"
+      end
+
+      def pipe_stdin
+        File.join pipe_directory, 'pipe_stdin'
+      end
+
+      def pipe_stdout
+        File.join pipe_directory, 'pipe_stdout'
+      end
+
+      def attach_to_process
+        EM.attach(File.open(pipe_stdout, File::NONBLOCK + File::RDONLY), LineProcessor) do |lp|
+          lp.on_line = method(:receive_stdout)
+        end
+
+        EM::PidPoller.on_exit pid, method(:process_exited)
+
+        EM.next_tick {
+          post_init
+          process_watched
+        }
+      end
+
+      def send_stdin line
+        File.open(pipe_stdin, 'w+') do |f|
+          f.write "#{line}\n"
+        end
+      end
+    end
+  end
+end

data/lib/eventmachine/profile.rb

@@ -0,0 +1,16 @@
+module EM
+  def self.profile
+    started_at = Time.now
+    iterations = 0
+    iteration_started_at = Time.now
+
+    EM.add_periodic_timer(1) do
+      iterations += 1
+      total_delta = ((Time.now - started_at) - iterations)
+      iteration_delta = (Time.now - iteration_started_at) - 1
+      iteration_started_at = Time.now
+
+      puts "iteration: #{iteration_delta.round(4)} total:#{total_delta.round(4)}"
+    end    
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: em-process-buffer
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Dave Newman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc.4
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+description: A restartable process watcher that buffers STDIN and STDOUT
+email:
+- dave@whatupdave.com
+executables:
+- buffer-process
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/buffer-process
+- em-process-buffer.gemspec
+- examples/in-out
+- examples/simple.rb
+- examples/timer.rb
+- lib/core_ext/process.rb
+- lib/eventmachine/line_processor.rb
+- lib/eventmachine/pid_poller.rb
+- lib/eventmachine/process_buffer.rb
+- lib/eventmachine/process_buffer/version.rb
+- lib/eventmachine/process_buffer/watcher.rb
+- lib/eventmachine/profile.rb
+homepage: https://github.com/minefold/em-process-buffer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- bin
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A restartable process watcher that buffers STDIN and STDOUT
+test_files: []