process_tail 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8de878e91fb0d39a77238a19bcb567e6257ed449
+  data.tar.gz: 9b4353b4c9e7cd4ed6ee44cdc9796310448912a3
+SHA512:
+  metadata.gz: dec2d6a557f9c826234c0fdbc0d4bc19eca4e35c28d303d63a9e7078e3e93c72684ea469eb6ae6581a97e2598602b89380d60b19301139ab6b812fcfa0fdc360
+  data.tar.gz: b71a3dc8ca8bccd242ccfa2148e777c3063b3941a169b50fe09858b25e23df0921f9e42bafc022830d75417cad0e8c51e66996fdc85d6702b50dc74813ac9136

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in process_tail.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Hika Hibariya
+
+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,45 @@
+# ProcessTail
+
+https://github.com/hibariya/process_tail
+
+## Description
+
+ProcessTail traces other process' write(2) system call and copy its buffer.
+So you can get other process outputs.
+
+## Problems
+
+* Mac OSX and Windows are not supported at the moment
+* SEGV occures occasionally
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'process_tail'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install process_tail
+
+## Usage
+
+```ruby
+ProcessTail.open pid, :stdout do |io|
+  puts "Recent stdout of #{pid}: #{io.gets}"
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/hibariya/process_tail/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 a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new 'process_tail' do |ext|
+  ext.lib_dir = 'lib/process_tail'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:compile, :spec]

data/ext/process_tail/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+%w(string.h sys/ptrace.h sys/syscall.h sys/types.h sys/user.h sys/wait.h ruby.h ruby/thread.h).each do |h|
+  abort "missing #{h}" unless have_header(h)
+end
+
+abort 'missing ptrace' unless have_func('ptrace', 'sys/ptrace.h')
+
+%w(orig_rax rdi rdx rsi rdx).each do |m|
+  abort "missing #{m}" unless have_struct_member('struct user_regs_struct', m, 'sys/user.h')
+end
+
+create_makefile 'process_tail/process_tail'

data/ext/process_tail/process_tail.c

@@ -0,0 +1,157 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ptrace.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <ruby.h>
+#include <ruby/thread.h>
+
+struct
+process_tail_args {
+  pid_t pid;
+  int *status;
+  unsigned int fd;
+  VALUE io;
+};
+
+static void *
+process_tail_waitpid(void *argp)
+{
+  struct process_tail_args *args = argp;
+
+  waitpid(args->pid, args->status, WUNTRACED | WCONTINUED);
+
+  return NULL;
+}
+
+static int
+process_tail_attach(void *argp)
+{
+  struct process_tail_args *args = argp;
+
+  if (ptrace(PTRACE_ATTACH, args->pid, NULL, NULL) < 0) {
+    rb_sys_fail("PTRACE_ATTACH");
+    return -1;
+  }
+
+  rb_thread_call_without_gvl(process_tail_waitpid, (void *)argp, RUBY_UBF_PROCESS, NULL);
+
+  return 0;
+}
+
+static VALUE
+process_tail_detach(VALUE argp)
+{
+  struct process_tail_args *args = (void *)argp;
+
+  ptrace(PTRACE_DETACH, args->pid, NULL, NULL);
+
+  return Qnil;
+}
+
+static void
+process_tail_get_data(pid_t pid, long addr, char *string, int len)
+{
+  long data;
+  int  i;
+
+  for (i = 0; i < len; i += sizeof(long)) {
+    data = ptrace(PTRACE_PEEKDATA, pid, addr + i);
+
+    memcpy(string + i, &data, sizeof(long));
+  }
+
+  string[len] = '\0';
+}
+
+static VALUE
+process_tail_loop(VALUE argp)
+{
+  struct process_tail_args *args = (void *)argp;
+  struct user_regs_struct regs;
+  int in_syscall = 0;
+  int signal     = 0;
+  int status;
+  char *string   = NULL;
+
+  args->status = &status;
+
+  while (ptrace(PTRACE_SYSCALL, args->pid, NULL, signal) == 0) {
+    rb_thread_call_without_gvl(process_tail_waitpid, args, RUBY_UBF_PROCESS, NULL);
+
+    signal = 0;
+
+    if (WIFEXITED(status)) {
+      return Qnil;
+    }
+
+    if (!WIFSTOPPED(status)) {
+      continue;
+    }
+
+    switch (WSTOPSIG(status)) {
+      case SIGTRAP:
+        ptrace(PTRACE_GETREGS, args->pid, 0, &regs);
+
+        if (regs.orig_rax != SYS_write) {
+          continue;
+        }
+
+        in_syscall = 1 - in_syscall;
+        if (in_syscall && (args->fd == 0 || regs.rdi == args->fd)) {
+          string = malloc(regs.rdx + sizeof(long));
+          process_tail_get_data(args->pid, regs.rsi, string, regs.rdx);
+
+          if (rb_funcall(args->io, rb_intern("closed?"), 0) == Qtrue) {
+            return Qnil;
+          }
+
+          rb_io_write(args->io, rb_str_new_cstr(string));
+
+          free(string);
+        }
+      case SIGVTALRM:
+        break;
+      case SIGSTOP:
+        break;
+      default:
+        signal = WSTOPSIG(status);
+    }
+
+    rb_thread_schedule();
+  }
+
+  return Qnil;
+}
+
+static VALUE
+process_tail_trace(VALUE klass, VALUE pidp, VALUE fdp, VALUE io)
+{
+  pid_t pid       = (pid_t)FIX2INT(pidp);
+  unsigned int fd = (unsigned int)FIX2INT(fdp);
+
+  struct process_tail_args args = {pid, NULL, fd, io};
+
+  Check_Type(pidp, T_FIXNUM);
+  Check_Type(fdp, T_FIXNUM);
+  Check_Type(io, T_FILE);
+
+  if (process_tail_attach((void *)&args) == 0) {
+    rb_ensure(process_tail_loop, (VALUE)&args, process_tail_detach, (VALUE)&args);
+  }
+
+  return Qnil;
+}
+
+void
+Init_process_tail()
+{
+  VALUE ProcessTail;
+
+  ProcessTail = rb_define_module("ProcessTail");
+  rb_define_singleton_method(ProcessTail, "do_trace", process_tail_trace, 3);
+}

data/lib/process_tail.rb

@@ -0,0 +1,50 @@
+require 'process_tail/process_tail'
+require 'process_tail/version'
+
+module ProcessTail
+  class << self
+    def open(pid, fd = :stdout)
+      read_io, thread = trace(pid, fd)
+
+      block_given? ? yield(read_io) : read_io
+    ensure
+      finalize = -> {
+        read_io.close unless read_io.closed?
+        thread.kill
+      }
+
+      block_given? ? finalize.call : at_exit(&finalize)
+    end
+
+    def trace(pid, fd = :stdout)
+      read_io, write_io = IO.pipe
+
+      thread = Thread.fork {
+        begin
+          do_trace pid, extract_fd(fd), write_io
+        ensure
+          begin
+            [read_io, write_io].each do |io|
+              io.close unless io.closed?
+            end
+          rescue IOError; end
+        end
+      }
+
+      [read_io, thread]
+    end
+
+    def extract_fd(name)
+      case name
+      when :stdout
+        1
+      when :stderr
+        2
+      when :all
+        0
+      else
+        Integer(name)
+      end
+    end
+  end
+end

data/lib/process_tail/version.rb

@@ -0,0 +1,3 @@
+module ProcessTail
+  VERSION = '0.0.1'
+end

data/process_tail.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'process_tail/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'process_tail'
+  spec.version       = ProcessTail::VERSION
+  spec.authors       = ['Hika Hibariya']
+  spec.email         = ['hibariya@gmail.com']
+  spec.summary       = %q{Get other process outputs.}
+  spec.homepage      = 'https://github.com/hibariya/process_tail'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.extensions = %w(ext/process_tail/extconf.rb)
+
+  spec.add_development_dependency 'bundler',       '~> 1.7'
+  spec.add_development_dependency 'rake',          '~> 10.0'
+  spec.add_development_dependency 'rake-compiler', '~> 0.9.5'
+  spec.add_development_dependency 'rspec',         '~> 3.1.0'
+end

data/spec/process_tail_spec.rb

@@ -0,0 +1,66 @@
+require 'process_tail'
+
+describe ProcessTail do
+  def process_maker(&fn)
+     -> {
+      Process.fork {
+        trap :USR1 do
+          sleep 0.1 # XXX :(
+
+          fn.call if fn
+        end
+
+        sleep
+      }
+    }
+  end
+
+  def expect_same_output_and_no_error(fd, method, string)
+    greeting = process_maker { send(method, string) }
+    pid      = greeting.call
+    io, th   = ProcessTail.trace(pid, fd)
+
+    Process.kill :USR1, pid # resume child
+
+    "#{string}\n".each_line do |expected|
+      expect(io.gets).to eq expected
+    end
+
+    Process.kill :TERM, pid
+
+    expect { th.join }.to_not raise_error
+  end
+
+  describe '.open' do
+    specify 'without block' do
+      pid = process_maker.call
+
+      read_io = ProcessTail.open(pid, :stdout)
+
+      expect(read_io).to_not be_closed
+
+      read_io.close
+    end
+
+    specify 'with block' do
+      pid     = process_maker.call
+      read_io = nil
+
+      ProcessTail.open pid, :stdout  do |io|
+        read_io = io
+
+        expect(read_io).to_not be_closed
+      end
+
+      expect(read_io).to be_closed
+    end
+  end
+
+  describe '.trace' do
+    it do
+      expect_same_output_and_no_error :stdout, :puts, 'HELLO'
+      expect_same_output_and_no_error :stderr, :warn, 'HELLO'
+      expect_same_output_and_no_error :stdout, :puts, "HELLO\nLOVE AND KISSES"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: process_tail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hika Hibariya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: 
+email:
+- hibariya@gmail.com
+executables: []
+extensions:
+- ext/process_tail/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/process_tail/extconf.rb
+- ext/process_tail/process_tail.c
+- lib/process_tail.rb
+- lib/process_tail/version.rb
+- process_tail.gemspec
+- spec/process_tail_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/hibariya/process_tail
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Get other process outputs.
+test_files:
+- spec/process_tail_spec.rb
+- spec/spec_helper.rb