childprocess-server 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjhjOTBjNTljNzBkMjE4ZmJhODAxNTJiOWU5NzQzYmY3Zjc2YTQ5MA==
+  data.tar.gz: !binary |-
+    ZTQyZTBiNmNlMGNmZGFmY2U4ODgzOTFjYmMyZDk5ZmMxNDE0YjA2ZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MDgzYWRjYTFkZGJiYjc0NDg1NzlhYjYwMmFkNGFiODEzNWM3OGM2ZmQxNTNh
+    ZGZjYTJhM2ZhYzVlOGI1Y2Q2N2E2MTJiMmE5YmM4YmE5YzI2YmZjNGYzNGQ2
+    MDhiZWIyNWU3N2VhZTIwNGYzY2UzNDY5NTQxYjFkMWIzMGI1Yjc=
+  data.tar.gz: !binary |-
+    YzA4Y2YzOTE2MTgxNjdmNDAxM2RmM2UyNGQ5OGI5NjE0ZjFiOTNlNzQzMjkw
+    YjEwZGM4MGI5MzdiNWRmZDI2MDc1ZjBmYTY3ZGVhN2Q2MzA3MWU2ZDIxOGJk
+    YmNjMTY5ZGZkYWYxYTMwMWJmYTJhOWRlMzBhMGVlMjk5YzM2M2Y=

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2013 WU Jun <quark@zju.edu.cn>
+
+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,72 @@
+# childprocess-server
+
+Manage and interact with processes, remotely (via dRuby).
+
+## Installation
+
+```bash
+gem install childprocess-server
+```
+
+## Usage
+
+### Standalone
+
+```ruby
+require 'childprocess-server'
+server = ChildProcess::Server.new
+
+# Run a process
+pid = server.launch('sleep', '1000')
+server.alive?(pid) # => true
+server.stop(pid)
+server.alive?(pid) # => false
+
+# Run 'echo', get output
+pid = server.launch('echo', 'hello')
+server.read_output(pid) # => "hello\n"
+server.alive?(pid) # => false
+
+# Run 'cat', write stdin interactively
+pid = server.launch('cat')
+server.write_input(pid, "foo\n")
+server.read_output(pid) # => "foo\n"
+server.write_input(pid, "bar\n")
+server.read_output(pid) # => "foo\nbar\n"
+server.stop(pid)
+
+# List all process ids managed
+# Note: exited processes are also listed.
+server.list_pids # => [ ... ]
+
+# Clean up
+server.clean_up
+server.list_pids # => []
+```
+
+### Client / Server
+
+```ruby
+DRB_URI = 'drbunix://tmp/a.socket'
+
+# Server side
+ChildProcess::Server.new.start_service(DRB_URI) # will block by default
+
+# Client side
+server = ChildProcess::Server.connect(DRB_URI)
+pid = server.launch('sort', '-n')
+server.write_input(pid, "20\n10\n2\n1\n")
+server.read_output(pid) # => "1\n2\n10\n20\n"
+```
+
+## Notes
+
+* This library is thread-safe.
+* This library does not have authentic feature.
+  Set file system permissions or firewall for security.
+* After `stop`, output can still be read using `read_output`,
+  because outputs are stored in temporary files.
+  Use `clean_up` to delete them immediately.
+  Otherwise they are deleted when server exits.
+* If `read_output` or `write_input` encounters errors,
+  they just return `nil` instead of raising an error.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'yard'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new
+YARD::Rake::YardocTask.new
+
+task :doc => [:yard]
+task :test => [:spec]

data/childprocess-server.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name = 'childprocess-server'
+  s.version = '0.1.1'
+  s.date = Date.civil(2013,3,31)
+  s.summary = 'Manage and interact with processes, remotely.'
+  s.description = 'Manage and interact with CLI processes, remotely via dRuby.'
+  s.authors = ["Wu Jun"]
+  s.email = 'quark@zju.edu.cn'
+  s.homepage = 'https://github.com/quark-zju/childprocess-server'
+  s.require_paths = ['lib']
+  s.licenses = ['MIT']
+  s.has_rdoc = 'yard'
+  s.files = %w(LICENSE README.md Rakefile childprocess-server.gemspec)
+  s.files += Dir['{lib,spec}/**/*.rb']
+  s.add_dependency 'childprocess', '~> 0.3.9'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 2.13'
+  s.add_development_dependency 'yard', '~> 0.8'
+  s.test_files = Dir['spec/**/*.rb']
+end
+

data/lib/childprocess-server.rb

@@ -0,0 +1 @@
+require 'childprocess/server'

data/lib/childprocess/server.rb

@@ -0,0 +1,123 @@
+require 'drb/drb'
+require 'childprocess'
+require 'thread'
+require 'tempfile'
+
+class ChildProcess::Server
+
+  # Connect to existing DRb service.
+  #
+  # @param uri [String] drb path
+  # @return [DrbObject<Server>] remote server
+  def self.connect(uri)
+    DRb.start_service
+    DRbObject.new_with_uri(uri)
+  end
+
+  # Start DRb service.
+  #
+  # @param wait [Bool] whether to block and wait for drb service to end
+  # @param uri [String] drb path
+  # @return [DRb::DRbServer]
+  def start_service(uri, wait = true)
+    server = DRb.start_service(uri, self)
+    DRb.thread.join if wait
+    server
+  end
+
+  def initialize
+    @processes = {}
+    @mutex = Mutex.new
+  end
+
+  # Launch a process in background.
+  #
+  # @param commands [Array<String>] commands
+  # @return [Integer] pid
+  def launch(*commands)
+    output = Tempfile.new('cps-out')
+    output.sync = true
+
+    process = ChildProcess.build(*commands)
+    process.io.stdout = process.io.stderr = output
+    process.duplex = true
+    process.start
+
+    pid = process.pid
+    access_processes do |processes|
+      processes[pid] = process
+    end
+    pid
+  end
+
+  # Read output, will not block.
+  #
+  # @param pid [Integer] process id
+  # @return [String] output so far, <tt>nil</tt> on error
+  def read_output(pid)
+    access_processes do |processes|
+      File.read(processes[pid].io.stdout.path) rescue nil 
+    end
+  end
+
+  # Write to input.
+  #
+  # @param pid [Integer] process id
+  def write_input(pid, content)
+    access_processes do |processes|
+      processes[pid] && processes[pid].io.stdin.write(content) rescue nil
+    end
+  end
+
+  # List process ids managed by this server.
+  #
+  # @return [Array<Integer>] process ids
+  def list_pids
+    access_processes do |processes|
+      processes.keys
+    end
+  end
+
+  # Check whether a process managed by this server is alive.
+  #
+  # @param pid [Integer] process id
+  # @return [Bool] whether that process is alive,
+  #                <tt>nil</tt> if that process is not managed by this server
+  def alive?(pid)
+    access_processes do |processes|
+      processes[pid] && processes[pid].alive?
+    end
+  end
+
+  # Stop a process managed by this server.
+  #
+  # @param pid [Integer] process id
+  def stop(pid)
+    access_processes do |processes|
+      processes[pid] && processes[pid].stop
+    end
+  end
+
+  # Clean up exited processes.
+  def clean_up
+    access_processes do |processes|
+      processes.values.select(&:exited?).each do |process|
+        process.io.stdout.path.unlink rescue nil
+      end
+      processes.delete_if { |_, process| process.exited? }
+      # Do not leak @processes outside
+      # We are using dRuby, keep input/output objects simple
+      nil
+    end
+  end
+
+  protected
+
+  # Access processes, exclusively.
+  def access_processes
+    @mutex.synchronize do
+      yield @processes
+    end
+  end
+
+end

data/spec/childprocess/server_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'childprocess/server'
+
+shared_examples_for 'common-server-tests' do
+  describe 'for external processes' do
+    it 'runs "true"' do
+      pid = server.launch('true')
+      pid.should > 0
+      server.list_pids.should include(pid)
+      server.read_output(pid).should be_empty
+      server.stop(pid)
+      server.alive?(pid).should be_false
+      server.clean_up.should be_nil
+      server.alive?(pid).should be_nil
+      server.list_pids.should_not include(pid)
+    end
+
+    it 'runs "cat" interactively' do
+      pid = server.launch('stdbuf', '-o0', 'cat')
+      server.alive?(pid).should be_true
+      (server.read_output(pid) || '').should be_empty
+      server.write_input(pid, "a\n")
+      sleep 0.1
+      server.read_output(pid).should == "a\n"
+      server.write_input(pid, "bc\n")
+      sleep 0.1
+      server.read_output(pid).should == "a\nbc\n"
+      server.stop(pid)
+      server.alive?(pid).should be_false
+      server.clean_up.should be_nil
+    end
+  end
+
+  describe 'for processes not managed' do
+    it '#read_output' do
+      server.read_output($$).should be_nil
+    end
+
+    it '#alive?' do
+      server.alive?($$).should be_nil
+    end
+
+    it 'stop' do
+      expect do
+        server.stop($$)
+      end.to_not raise_error
+    end
+
+    it '#write_input' do
+      expect do
+        server.write_input($$, 'test')
+      end.to_not raise_error
+    end
+  end
+end 
+
+describe 'standalone' do
+  let(:server) { ChildProcess::Server.new }
+
+  it_should_behave_like 'common-server-tests'
+end
+
+describe 'client-server' do
+  SOCKET_FILE = File.join(Dir.tmpdir, "csspec-#{$$}.socket")
+  DRB_URI = "drbunix://#{SOCKET_FILE}"
+  THREAD_COUNT = 10
+  CLIENT_COUNT = 4
+
+  before(:all) do
+    server = ChildProcess::Server.new
+    @service = server.start_service(DRB_URI, false)
+  end
+
+  after(:all) do
+    @service.stop_service
+    File.unlink(SOCKET_FILE) rescue nil
+  end
+
+  let(:server) { ChildProcess::Server.connect(DRB_URI) }
+
+  it_should_behave_like 'common-server-tests'
+
+  it 'accepts multiple connections' do
+    expect do
+      clients = CLIENT_COUNT.times.map { ChildProcess::Server.connect(DRB_URI) }
+      pids = clients.map { |client| client.launch('sleep', '3') }
+      server.list_pids.should include(*pids)
+      pids.each { |pid| server.stop(pid) }
+      server.clean_up
+    end.to_not change { server.list_pids }
+  end
+
+  it 'handle concurrent requests' do
+    expect do
+      threads = THREAD_COUNT.times.map do
+        Thread.new do
+          texts = CLIENT_COUNT.times.map { rand.to_s }
+          clients = CLIENT_COUNT.times.map { ChildProcess::Server.connect(DRB_URI) }
+          pids = clients.map.with_index do |client, i|
+            client.launch('echo', texts[i])
+          end
+          clients[0].list_pids.should include(*pids)
+          sleep 0.1
+          pids.map.with_index do |pid, i|
+            clients[rand(0...clients.size)].read_output(pid).should == "#{texts[i]}\n"
+          end
+        end
+      end
+      threads.each(&:join)
+      sleep 0.1
+      server.clean_up
+    end.to_not change { server.list_pids }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: childprocess-server
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Wu Jun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.9
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Manage and interact with CLI processes, remotely via dRuby.
+email: quark@zju.edu.cn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- childprocess-server.gemspec
+- lib/childprocess/server.rb
+- lib/childprocess-server.rb
+- spec/childprocess/server_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/quark-zju/childprocess-server
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Manage and interact with processes, remotely.
+test_files:
+- spec/childprocess/server_spec.rb
+- spec/spec_helper.rb
+has_rdoc: yard