process_tail 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85d86bdf54735a348134ab9abceec3610882fe23
-  data.tar.gz: 9f1e65346bd355e4fb1b9f9c83fdf8c45a16a224
+  metadata.gz: 3adc23055f8977b049a04d0b94ddb2f9a5740cf2
+  data.tar.gz: 680424fb0373ed7d1e429044920ced1033151278
 SHA512:
-  metadata.gz: e3da11ae5cece8697449bcea8307bc34e1af5b6cb3a39834e96d56f2b32d6306e4ac9070909c79bab0f2486f319a15de408d13df6982d9d3fa367163920c8387
-  data.tar.gz: 30b6556d39cf4b06169e518a69fe7a8c1b0b03a05e0f0db97bcd6abafee42625622048885fbc7452dfbf48cec4915983c2feb10aa6aae5ea132a7a7b8c770b56
+  metadata.gz: 90c7886af47819ac7ae13281bec9a157cb051569f1799dfa11d7edaa23ecdc1e3a1298febbb59ef6202fba679a32e28dbf87ecd34e0c23623c522406da51d846
+  data.tar.gz: ed2d69a06283896f786f36aa5a960ec9fc1e1b9d059840f15686c49a88d0611eb140e256b81599c0e66669122f2f579445c55015d57613e445f2add89594cd71

data/README.md

@@ -11,7 +11,6 @@ So you can get other process outputs.
 
 * Mac OSX and Windows are not supported at the moment
 * SEGV occures occasionally
-* Multithreaded process support
 
 ## Installation
 
@@ -31,12 +30,20 @@ Or install it yourself as:
 
 ## Usage
 
+### Get outputs as an IO object
+
 ```ruby
 ProcessTail.open pid, :stdout do |io|
   puts "Recent stdout of #{pid}: #{io.gets}"
 end
 ```
 
+### Show outputs instantly
+
+```bash
+$ process_tail $(pgrep PROCESS_NAME)
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/hibariya/process_tail/fork )

data/bin/process_tail

@@ -5,7 +5,11 @@ require 'process_tail'
 $stdout.sync = true
 
 ProcessTail.open Integer(ARGV[0]) do |io|
-  while c = io.getc
-    print c
+  begin
+    while c = io.getc
+      print c
+    end
+  rescue IOError
+    # NOP
   end
 end

data/ext/process_tail/extconf.rb

@@ -8,7 +8,10 @@ end
   abort "missing #{m}" unless have_struct_member('struct user_regs_struct', m, 'sys/user.h')
 end
 
-abort 'missing __WALL'                unless have_const('__WALL', 'sys/wait.h')
-abort 'missing PTRACE_O_TRACESYSGOOD' unless have_const('PTRACE_O_TRACESYSGOOD', 'sys/ptrace.h')
+%w(PTRACE_O_TRACESYSGOOD PTRACE_O_TRACEFORK PTRACE_O_TRACEVFORK PTRACE_O_TRACECLONE).each do |c|
+  abort "missing #{c}" unless have_const(c, 'sys/ptrace.h')
+end
+
+abort 'missing __WALL' unless have_const('__WALL', 'sys/wait.h')
 
 create_makefile 'process_tail/process_tail'

data/ext/process_tail/process_tail.c

@@ -15,11 +15,26 @@ typedef struct pt_tracee {
   struct pt_tracee *next;
 } pt_tracee_t;
 
-typedef struct pt_wait_args {
+typedef struct {
   int *status;
   pid_t pid;
 } pt_wait_args_t;
 
+typedef struct {
+  unsigned int fd;
+  pt_tracee_t *tracee;
+  VALUE *wait_queue;
+} pt_loop_args_t;
+
+static void
+pt_tracee_initialize(pt_tracee_t *tracee)
+{
+  tracee->pid       = 0;
+  tracee->activated = 0;
+  tracee->dead      = 0;
+  tracee->next      = NULL;
+}
+
 static pt_tracee_t *
 pt_tracee_add(pt_tracee_t **headpp, pid_t pid)
 {
@@ -29,10 +44,9 @@ pt_tracee_add(pt_tracee_t **headpp, pid_t pid)
     exit(EXIT_FAILURE);
   }
 
-  tracee->pid       = pid;
-  tracee->activated = 0;
-  tracee->dead      = 0;
-  tracee->next      = (struct pt_tracee *)*headpp;
+  pt_tracee_initialize(tracee);
+  tracee->pid  = pid;
+  tracee->next = (struct pt_tracee *)*headpp;
 
   (*headpp) = tracee;
 
@@ -42,14 +56,15 @@ pt_tracee_add(pt_tracee_t **headpp, pid_t pid)
 static pt_tracee_t *
 pt_tracee_find_or_add(pt_tracee_t **headpp, pid_t pid)
 {
-  pt_tracee_t *tracee = *headpp;
+  pt_tracee_t *headp   = *headpp;
+  pt_tracee_t *current = headp;
 
-  while (tracee != NULL) {
-    if (tracee->pid == pid) {
-      return tracee;
+  while (current) {
+    if (current->pid == pid) {
+      return current;
     }
 
-    tracee = tracee->next;
+    current = current->next;
   }
 
   return pt_tracee_add(headpp, pid);
@@ -58,14 +73,14 @@ pt_tracee_find_or_add(pt_tracee_t **headpp, pid_t pid)
 static int
 pt_tracee_wipedoutq(pt_tracee_t *headp)
 {
-  pt_tracee_t *tracee = headp;
+  pt_tracee_t *current = headp;
 
-  while (tracee != NULL) {
-    if (tracee->dead == 0) {
+  while (current) {
+    if (current->dead == 0) {
       return 0;
     }
 
-    tracee = tracee->next;
+    current = current->next;
   }
 
   return 1;
@@ -74,20 +89,14 @@ pt_tracee_wipedoutq(pt_tracee_t *headp)
 static void
 pt_tracee_free(pt_tracee_t **headpp)
 {
-  pt_tracee_t *tracee  = *headpp;
+  pt_tracee_t *tracee = *headpp;
 
-  if (tracee->next) {
+  if (tracee) {
     pt_tracee_free(&tracee->next);
-  }
-
-  free(tracee);
-  (*headpp) = NULL;
-}
 
-static int
-pt_io_closedq(VALUE io)
-{
-  return rb_funcall(io, rb_intern("closed?"), 0) == Qtrue;
+    free(tracee);
+    tracee = NULL;
+  }
 }
 
 static void *
@@ -101,7 +110,7 @@ pt_wait(void *argp)
 }
 
 static void
-pt_get_data(pid_t pid, long addr, char *string, int length)
+pt_read_data(pid_t pid, long addr, char *string, int length)
 {
   int  i;
   long data;
@@ -123,39 +132,33 @@ pt_ptrace_syscall(pid_t pid, long signal)
   rb_thread_schedule();
 }
 
-static void
-pt_loop(unsigned int fd, VALUE write_io, VALUE read_io, VALUE wait_queue, pt_tracee_t *tracee_headp)
+static VALUE
+pt_loop(VALUE loop_args)
 {
+  pt_loop_args_t *args = (void *)loop_args;
+
   char *string = NULL;
   int syscall  = 0;
   int status;
-  long signal;
   pid_t pid;
   pt_tracee_t *tracee;
   pt_wait_args_t pt_wait_args = {&status};
 
-  // NOTE: system call: eax, arguments: rdi, rsi, rdx, r10, r8, r9
+  // NOTE: system call: orig_rax, arguments: rdi, rsi, rdx, r10, r8, r9
   struct user_regs_struct regs;
 
   while (1) {
     rb_thread_call_without_gvl(pt_wait, &pt_wait_args, RUBY_UBF_PROCESS, NULL);
 
-    signal = 0;
     pid    = pt_wait_args.pid;
-    tracee = pt_tracee_find_or_add(&tracee_headp, pid);
-
-    if (pt_io_closedq(read_io)) {
-      pt_tracee_free(&tracee_headp);
-
-      return;
-    }
+    tracee = pt_tracee_find_or_add(&args->tracee, pid);
 
     if (tracee->activated == 0) {
-      ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD);
       tracee->activated = 1;
+      rb_funcall(*args->wait_queue, rb_intern("enq"), 1, INT2FIX((int)pid));
 
-      rb_funcall(wait_queue, rb_intern("enq"), 1, INT2FIX((int)pid));
-      pt_ptrace_syscall(pid, signal);
+      ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE);
+      pt_ptrace_syscall(pid, 0);
 
       continue;
     }
@@ -163,18 +166,15 @@ pt_loop(unsigned int fd, VALUE write_io, VALUE read_io, VALUE wait_queue, pt_tra
     if (WIFEXITED(status) || WIFSIGNALED(status)) {
       tracee->dead = 1;
 
-      if (pt_tracee_wipedoutq(tracee_headp)) {
-        pt_tracee_free(&tracee_headp);
-
-        return;
+      if (pt_tracee_wipedoutq(args->tracee)) {
+        return Qnil;
       }
 
       continue;
     }
 
     if (!(WIFSTOPPED(status) && WSTOPSIG(status) & 0x80)) {
-      signal = WSTOPSIG(status);
-      pt_ptrace_syscall(pid, signal);
+      pt_ptrace_syscall(pid, WSTOPSIG(status));
 
       continue;
     }
@@ -182,35 +182,30 @@ pt_loop(unsigned int fd, VALUE write_io, VALUE read_io, VALUE wait_queue, pt_tra
     ptrace(PTRACE_GETREGS, pid, 0, &regs);
 
     if (regs.orig_rax != SYS_write) {
-      pt_ptrace_syscall(pid, signal);
+      pt_ptrace_syscall(pid, 0);
 
       continue;
     }
 
     syscall = 1 - syscall;
-    if (syscall && (fd == 0 || regs.rdi == fd)) {
+    if (syscall && (args->fd == 0 || regs.rdi == args->fd)) {
       string = malloc(regs.rdx + sizeof(long));
 
       if (string == NULL) {
         exit(EXIT_FAILURE);
       }
 
-      pt_get_data(pid, regs.rsi, string, regs.rdx);
-
-      if (pt_io_closedq(read_io)) {
-        free(string);
-        pt_tracee_free(&tracee_headp);
-
-        return;
-      }
+      pt_read_data(pid, regs.rsi, string, regs.rdx);
 
-      rb_io_write(write_io, rb_str_new_cstr(string));
+      rb_yield(rb_ary_new_from_args(3, rb_str_new_cstr(string), INT2FIX((int)pid), INT2FIX(args->fd)));
 
       free(string);
     }
 
-    pt_ptrace_syscall(pid, signal);
+    pt_ptrace_syscall(pid, 0);
   }
+
+  return Qnil;
 }
 
 static VALUE
@@ -240,15 +235,24 @@ pt_detach(VALUE klass, VALUE pidv)
 }
 
 static VALUE
-pt_trace(VALUE klass, VALUE fdp, VALUE write_io, VALUE read_io, VALUE wait_queue)
+pt_finalize(VALUE traceev)
+{
+  pt_tracee_t *tracee = (void *)traceev;
+
+  pt_tracee_free(&tracee);
+
+  return Qnil;
+}
+
+static VALUE
+pt_trace(VALUE klass, VALUE fdv, VALUE wait_queue)
 {
-  pt_tracee_t *tracee_headp = NULL;
+  pt_tracee_t  *tracee = NULL;
+  pt_loop_args_t loop_args = {FIX2INT(fdv), tracee, &wait_queue};
 
-  Check_Type(fdp,         T_FIXNUM);
-  Check_Type(write_io,    T_FILE);
-  Check_Type(read_io,     T_FILE);
+  Check_Type(fdv, T_FIXNUM);
 
-  pt_loop((unsigned int)FIX2INT(fdp), write_io, read_io, wait_queue, tracee_headp);
+  rb_ensure(pt_loop, (VALUE)&loop_args, pt_finalize, (VALUE)tracee);
 
   return Qnil;
 }
@@ -258,7 +262,7 @@ Init_process_tail()
 {
   VALUE ProcessTail = rb_define_module("ProcessTail");
 
-  rb_define_singleton_method(ProcessTail, "attach",   pt_attach, 1);
-  rb_define_singleton_method(ProcessTail, "do_trace", pt_trace,  4);
-  rb_define_singleton_method(ProcessTail, "detach",   pt_detach, 1);
+  rb_define_private_method(rb_singleton_class(ProcessTail), "attach",   pt_attach, 1);
+  rb_define_private_method(rb_singleton_class(ProcessTail), "do_trace", pt_trace,  2);
+  rb_define_private_method(rb_singleton_class(ProcessTail), "detach",   pt_detach, 1);
 }

data/lib/process_tail/version.rb

@@ -1,3 +1,3 @@
 module ProcessTail
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/process_tail.rb

@@ -7,50 +7,69 @@ module ProcessTail
 
   class << self
     def open(pid, fd = :stdout)
-      io = trace(pid, fd)
+      read_io, write_io = IO.pipe
+      trace_thread      = trace(pid, fd) {|str, *|
+        unless read_io.closed?
+          write_io.write str
+        else
+          trace_thread.kill
+        end
+      }
+
+      wait_thread = fork_wait_thread(trace_thread, [read_io, write_io])
+
+      if block_given?
+        value = yield(read_io)
+
+        trace_thread.kill
+        wait_thread.join
 
-      block_given? ? yield(io) : io
-    ensure
-      io.close if block_given? && !io.closed?
+        value
+      else
+        read_io
+      end
     end
 
-    def trace(pid, fd = :stdout)
+    def trace(pid, fd = :stdout, &block)
       TRACE_LOCK.synchronize {
-        trace_without_lock(pid, fd)
+        trace_without_lock(pid, fd, &block)
       }
     end
 
     private
 
-    def trace_without_lock(pid, fd)
-      read_io, write_io = IO.pipe
-      task_ids   = extract_task_ids(pid)
-      wait_queue = Queue.new
-
-      thread = Thread.fork {
+    def trace_without_lock(pid, fd, &block)
+      task_ids     = extract_task_ids(pid)
+      wait_queue   = Queue.new
+      trace_thread = Thread.fork {
         begin
-          extract_task_ids(pid).each do |tid|
+          task_ids.each do |tid|
             attach tid
           end
 
-          do_trace extract_fd(fd), write_io, read_io, wait_queue
+          do_trace extract_fd(fd), wait_queue, &block
         ensure
-          write_io.close unless write_io.closed?
-
           task_ids.each do |tid|
             detach tid
           end
         end
       }
 
-      at_exit do
-        thread.kill
-        thread.join
-      end
-
       wait_all_attach task_ids, wait_queue
 
-      read_io
+      trace_thread
+    end
+
+    def fork_wait_thread(trace_thread, pipe)
+      Thread.fork {
+        begin
+          trace_thread.join
+        ensure
+          pipe.each do |io|
+            io.close unless io.closed?
+          end
+        end
+      }
     end
 
     def wait_all_attach(task_ids, waitq)

data/spec/process_tail_spec.rb

@@ -21,15 +21,14 @@ describe ProcessTail do
   def expect_same_output_and_no_error(fd, method, string)
     greeting    = process_maker { send(method, string) }
     pid         = greeting.call
-    io          = ProcessTail.trace(pid, fd)
 
-    Process.kill :USR1, pid # resume child
+    ProcessTail.open pid, fd do |io|
+      Process.kill :USR1, pid # resume child
 
-    "#{string}\n".each_line do |expected|
-      expect(io.gets).to eq expected
+      "#{string}\n".each_line do |expected|
+        expect(io.gets).to eq expected
+      end
     end
-
-    io.close
   end
 
   around do |example|
@@ -40,11 +39,12 @@ describe ProcessTail do
       timeout 5 do
         example.run
       end
-
     ensure
       $recorded_children.each do |child|
         Process.kill :TERM, child
       end
+
+      sleep 1 # FIXME :(
     end
   end
 
@@ -71,9 +71,7 @@ describe ProcessTail do
 
       expect(read_io).to be_closed
     end
-  end
 
-  describe '.trace' do
     specify 'simple stdout'  do
       expect_same_output_and_no_error :stdout, :puts, 'HELLO'
     end
@@ -82,6 +80,10 @@ describe ProcessTail do
       expect_same_output_and_no_error :stderr, :warn, 'HELLO'
     end
 
+    specify 'multiline' do
+      expect_same_output_and_no_error :stdout, :puts, "HELLO\nHELLO"
+    end
+
     specify 'multithreaded' do
       pid = Process.fork {
         trap :USR1 do
@@ -90,7 +92,7 @@ describe ProcessTail do
 
         Thread.fork do
           trap :USR2 do
-            puts 'HELLO'
+            puts 'LOVE AND KISSES'
           end
 
           sleep
@@ -100,19 +102,15 @@ describe ProcessTail do
       }
 
       $recorded_children << pid
-      io = ProcessTail.trace(pid, :stdout)
+      io = ProcessTail.open(pid, :stdout)
 
       Process.kill :USR1, pid
       Process.kill :USR2, pid
 
       expect(io.gets).to eq "HELLO\n"
-      expect(io.gets).to eq "HELLO\n"
+      expect(io.gets).to eq "LOVE AND KISSES\n"
 
       io.close
     end
-
-    specify 'multiline' do
-      expect_same_output_and_no_error :stdout, :puts, "HELLO\nLOVE AND KISSES"
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: process_tail
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Hika Hibariya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-08 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler