facets 1.7.46 → 1.8.0

data/work/more/commandrunner.rb

@@ -0,0 +1,101 @@
+class CommandRunner
+
+    attr :command
+    attr :child_pid
+
+    def initialize(*command)
+        @command        = command
+        @child_pid      = nil
+        @waiting_thread = nil
+
+        @read_pipe        = nil
+        @read_error_pipe  = nil
+        @write_pipe       = nil
+    end
+
+    def closeWrite
+        @write_pipe.close
+    end
+
+    def kill
+        Process.kill("KILL", @child_pid)
+    end
+
+    def read
+        return @read_pipe.read
+    end
+
+    def readError
+        return @read_error_pipe.read
+    end
+
+    def run
+        parent_to_child_read, parent_to_child_write             = IO.pipe
+        child_to_parent_read, child_to_parent_write             = IO.pipe
+        child_to_parent_error_read, child_to_parent_error_write = IO.pipe
+
+        @child_pid = fork do
+            parent_to_child_write.close
+            child_to_parent_read.close
+            child_to_parent_error_read.close
+
+            # Wait until parent is ready before we start doing anything
+            if parent_to_child_read.readchar.chr != "R"
+                raise "Unexpected input from parent"
+            end
+
+            $stdin.reopen(parent_to_child_read)
+            $stdout.reopen(child_to_parent_write)
+            $stderr.reopen(child_to_parent_error_write)
+
+            exec(*@command)
+        end
+
+        @waiting_thread = Thread.new(@child_pid) do |pid|
+            return_code = -1
+
+            begin
+                return_code = Process.waitpid2(pid)
+            rescue SystemError
+                raise "Process finished running already!"
+            end
+            return_code = return_code[1].exitstatus
+
+            return_code
+        end
+
+        child_to_parent_write.close
+        child_to_parent_error_write.close
+        parent_to_child_read.close
+
+        @read_pipe        = child_to_parent_read
+        @read_error_pipe  = child_to_parent_error_read
+        @write_pipe       = parent_to_child_write
+
+        @write_pipe.write("R")
+        @write_pipe.flush
+    end
+
+    #--------------------------------------------------------------------------
+    # Waits for command to exit
+    # Returns: The return code of the program when it exited
+    #--------------------------------------------------------------------------
+    def wait
+        if not @child_pid or not @waiting_thread
+            raise "Waiting for a process that has not started"
+        end
+
+        return_value = @waiting_thread.value
+
+        @waiting_thread = nil
+        @child_pid = nil
+
+        return return_value
+    end
+
+    def write(string)
+        @write_pipe.write(string)
+    end
+end
+
+

data/work/more/daemon.rb

@@ -0,0 +1,70 @@
+#
+# daemon.rb
+#
+#   Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU Lesser General Public License version 2 or later.
+#
+#   $Id: daemon.rb,v 1.2 2002/01/05 06:19:34 aamine Exp $
+#
+
+require 'socket'
+
+
+class Daemon
+
+  def self.exec( port, dir, debug = $DEBUG )
+    new(debug).exec port, dir
+  end
+
+  def initialize( debug = $DEBUG )
+    @debug = $DEBUG
+  end
+
+  def exec( port, dir )
+    if @debug then
+      Dir.chdir dir
+      wait 
+      return
+    end
+
+    fork do
+      Process.setsid
+      fork do
+        Dir.chdir dir
+        $stdin.close
+        $stdout.close
+        $stderr.close
+
+        wait
+      end
+
+      exit!
+    end
+    exit!
+  end
+
+  def wait
+    s = TCPServer.new( 10070 )
+
+    unless @debug then
+      trap( 'SIGINT' ) { exit! }
+      trap( 'SIGHUP' ) { exit! }
+      trap( 'SIGTERM' ) { exit! }
+    end
+
+    while true do
+      @sock = s.accept
+      begin
+        session
+      ensure
+        @sock.close
+      end
+    end
+  end
+
+  # abstract session
+
+end

data/work/more/debugger.rb

@@ -0,0 +1,167 @@
+###############################
+# WARNING! Expiremental code! #
+###############################
+
+# = debugger.rb
+#
+# == Copyright (c) 2006 Jan Molic
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# == Authors & Contributors
+#
+# * Jan Molic
+#
+# == Developer Notes
+#
+# TODO Is the name too generic?
+#
+
+# Author::    Jan Molic
+# Copyright:: Copyright (c) 2006 Jan Molic
+# License::   Ruby License
+
+require 'yaml'
+require 'logger'
+
+# = Debugger
+#
+# Debugger is an extension to Ruby's Logger which Adds nesting,
+# yaml dumps, backtrace and elapsed time to logs.
+#
+#   $log = Debugger.new( STDERR )
+#   $log.trace = true
+#   $log.debug( 'foo' ) { |log|
+#     log.debug( 'bar happened' )
+#   }
+#
+# which produces
+#
+#   D, [2006-06-19T14:39:19.635675 #13814] DEBUG -- : example2:10 > foo: START
+#   D, [2006-06-19T14:39:19.636447 #13814] DEBUG -- : example2:11 > foo > bar happened
+#   D, [2006-06-19T14:39:19.637723 #13814] DEBUG -- : example2:12 > foo > object dump
+#   - 1
+#   - 2
+#   - 3
+#   D, [2006-06-19T14:39:19.638646 #13814] DEBUG -- : example2:13 > foo > baz: START
+#   D, [2006-06-19T14:39:19.639234 #13814] DEBUG -- : example2:14 > foo > baz > ok
+#   D, [2006-06-19T14:39:19.639853 #13814] DEBUG -- : example2:13 > foo > baz: END (0.00056 sec)
+#   D, [2006-06-19T14:39:19.640445 #13814] DEBUG -- : example2:10 > foo: END
+#   (0.003999 sec)
+#
+
+class Debugger
+
+  DEBUG = 0
+  INFO = 1
+  WARN = 2
+  ERROR = 3
+  FATAL = 4
+  UNKNOWN = 5
+
+  METHOD_MAP = {
+    DEBUG => :debug,
+    INFO => :info,
+    WARN => :warn,
+    ERROR => :error,
+    FATAL => :fatal,
+    UNKNOWN => :unknown
+  }
+
+  attr_accessor :trace, :name, :parent
+
+  def initialize( output )
+    @parent = nil
+    @name = ''
+    @trace = false
+    @logger = Logger.new( output )
+    @level = @logger.level
+  end
+
+    # set level ( choose one of constants )
+  def level= l
+    @logger.level = l
+  end
+
+    # print easily findable "point" in debug
+  def point( str='---- XXXX ' )
+    do_debug( DEBUG, (str*5), nil )
+  end
+
+  def debug( a='', b=nil, &block )
+    do_debug( DEBUG, a, b, &block )
+  end
+
+  def info( a='', b=nil, &block )
+    do_debug( INFO, a, b, &block )
+  end
+
+  def warn( a='', b=nil, &block )
+    do_debug( WARN, a, b, &block )
+  end
+
+  def error( a='', b=nil, &block )
+    do_debug( ERROR, a, b, &block )
+  end
+
+  def fatal( a='', b=nil, &block )
+    do_debug( FATAL, a, b, &block )
+  end
+
+  # used internally
+  def get_path
+    if @parent
+      @parent.get_path + [ @name ]
+    else
+      []
+    end
+  end
+
+  private
+
+    def get_trace
+      ary = caller
+      1.upto( 7 ) { |i|
+        return ary[i] if ary[i] !~ /#{__FILE__}/
+      }
+      ''
+    end
+
+    def output( level, obj, dump_msg )
+      if level >= @logger.level
+        if ! obj.is_a?( String )
+          dump_msg ||= 'object dump'
+          obj = dump_msg + "\n" + obj.to_yaml
+        end
+        ary = []
+        ary << get_trace if @trace
+        path = get_path
+        ary += path if path
+        ary << obj
+        @logger.send( METHOD_MAP[level], ary.join(' > ') )
+      end
+    end
+
+    def do_debug( level, a, b, &block )
+      if block
+        output( level, "#{a}: START", '' )
+        dbg = self.clone
+        dbg.parent = self
+        dbg.name = a
+        start = Time.now
+        block.call( dbg )
+        total = Time.now - start
+        output( level, "#{a}: END (#{total} sec)", '' )
+      else
+        output( level, a, b )
+      end
+    end
+
+end

data/work/more/detach.rb

@@ -0,0 +1,423 @@
+=begin rdoc
+
+= Object#detach 
+
+  Written by Evan Webb <evan@fallingsnow.net>
+
+Detach an object into a seperate process.
+
+Simplest example expands to all objects.
+   
+   require 'detach'
+   
+   s = "blah"
+   s2 = s.detach
+   s2.size     # 4
+   s2.to_s     # blah
+
+
+This basic example is true for all objects. All methods
+are passed to the object running in the other process and
+the return of #detach can be used in exactly the same way
+as the original object.
+
+Useful in splitting of sections of a application that can
+then use their own thread table and will have better performance
+then running all parts of a large application under one ruby thread
+scheduler.
+
+=end
+
+require 'drb'
+
+
+module Dispatch
+
+    # These are created for each background work unit (method call)
+    # that is created. They keep stats and allow for indexing
+    # when the value is ready.
+    class BackgroundUnit
+        attr_accessor :unit_id, :start, :stop
+        attr_reader :value, :thread
+
+        def initialize(id)
+            @unit_id = id
+            @thread = nil
+            @start = nil
+            @stop = nil
+        end
+
+        # Sets the thread of the unit
+        def thread=(th)
+            @thread = th
+            @start = Time.now
+        end
+
+        # Sets the value of the unit
+        def value=(v)
+            @stop = Time.now
+            @value = v
+        end
+
+        # Indicates the elapse time spent on the unit
+        def elapse
+            @stop - @start
+        end
+
+        # Indicates if the unit has finished processing
+        def ready?
+            !@thread.alive?
+        end
+    end
+
+    # Attached as the front object to a DRb, and given it's own
+    # front object, method calls on this object spin a new thread
+    # to handle the method and returns a BackgroundObject right
+    # away. Future usage of said BackgroundObject causes it to
+    # request the real object from the Dispatch (via DRb), at
+    # which time operations may block. This allows for the time
+    # between object creation and object usage for the real remote
+    # object to do it's working, not blocking the local objects.
+    class BackgroundDispatch
+
+        undef :to_s
+        undef :to_a
+        undef :respond_to?
+
+        def initialize(front,drb=false)
+            @front = front
+            @units = Hash.new
+            @drb = drb
+        end
+
+        # This is defined to keep DRb and such from trying
+        # to move a the Dispatcher, which must remain in the same
+        # context as the called method. Though, having Thread
+        # objects referenced with @units makes that true as well.
+        def _dump(d)
+            raise TypeError, "can't be moved"
+        end
+
+        # Someone has requested an operation on
+        # this front object to be performed. Ok, lets spin
+        # of the method to do it's working and return a 
+        # BackgroundObject as a stand in.
+        def method_missing(msg_id, *a, &b)
+            # puts "Calling #{msg_id}..."
+            if @drb
+                obj = BackgroundObject.new(DRbObject.new(self))
+            else
+                obj = BackgroundObject.new(self)
+            end
+            
+            unit = BackgroundUnit.new(obj.index)
+            unit.thread = Thread.new(unit) { |u|
+                # puts " >> In thread, sending method to real object (#{obj.index})"
+                u.value = @front.__send__(msg_id, *a, &b)
+                # puts " >> Finished operation (#{obj.index})"
+            }
+            @units[obj.index] = unit
+            # puts "Returning a BO for #{obj.index}"
+            return obj
+        end
+
+        # Used fetch the value of the work unit associated with
+        # the BackgroundObject at index. This method blocks, 
+        # waiting until the value is ready before returning it.
+        def _get_obj(index)
+            # puts "Fetching object #{index} in #{Process.pid}"
+            # puts "Unit is #{@units[index].inspect}"
+            if not @units[index].ready?
+                @units[index].thread.join
+            end
+            # puts "Returning value.."
+            return @units[index].value
+        end
+
+        # Used to check if the work unit is ready.
+        def _obj_ready?(uid)
+            # puts "Checking for readiness in #{Process.pid}"
+            @units[uid].ready?
+        end
+
+        # Used for stats transparent back to the caller.
+        # This is done in seperate struct rather then just 
+        # returning the unit object because it can easily be 
+        # seralized and used on the local side of a DRb session
+        Stats = Struct.new(:start, :stop, :running)
+
+        # Returns the stats for a work unit.
+        def _obj_stats(uid)
+            unit = @units[uid]
+            if unit.nil?
+                return Stats.new
+            end
+            return Stats.new(unit.start,unit.stop,unit.thread.alive?)
+        end
+    end
+
+    # Used to create non-blocking remote method calls. Has an
+    # index of a work unit and a dispatch object to call on
+    # to do all the work.
+    class BackgroundObject
+
+        attr_reader :index
+
+        def initialize(dispatch)
+            @dispatch = dispatch
+            @index = self.object_id()
+        end
+
+        undef :to_s
+        undef :to_a
+        undef :respond_to?
+
+        # Passes all unknown method calls back to the 
+        # original object by way of the dispatch.
+        def method_missing(msg_id, *a, &b)
+            # puts "in #{Process.pid}, asking for #{msg_id} from a #{@dispatch.class}"
+            obj = @dispatch._get_obj(@index)
+            # puts "Ret is a #{obj.class}"
+            obj.__send__(msg_id,*a,&b)
+        end
+
+        # Returns true if the real object is ready.
+        def ready?
+            # puts "Checking for readiness from #{Process.pid}"
+            @dispatch._obj_ready?(@index)
+        end
+        alias :done? :ready?
+
+        # Returns stats for the backgrouded call.
+        def stats
+            @dispatch._obj_stats(@index)
+        end
+
+# I added when it choked needing this
+        def self._load(d)
+        end
+    end
+end
+
+
+
+class Object
+# Accepts a hash of options to use when detaching.
+#
+# :ps - Controls if the title of the new process is changed
+# to reflect it being a detached object.
+#
+# Values:
+# * :append - Append information to the current process title
+# * :replace - Replace the current process title all together
+# * :none - Don't change the process title at all
+#
+#
+# :name - Sets what the name of the process actually is.
+#
+# Values:
+# * :parent - Uses the current process title as the name of the 
+#   detached process (ie, $0 of the parent)
+# * String - Any String value is used as the name
+#
+#
+# :id - Sets what the id of the process will be in the new
+# process title.
+#
+# Values:
+# * :object  Uses a default id, looks like the default Object#to_s
+# * String   Any String value is used as the id
+#
+#
+# :die - Controls if the child process will be killed if the 
+# parent exits.
+#
+# Values:
+# * :parent  Detached object process follows the course of 
+#   the parent process
+# * :none    The detached object process will continue running 
+#   inspite of the fate of the parent process
+#
+# :path - The template of the location of the pipe used for 
+# communication between the parent and the detached process.
+#
+# Defaults to: '/tmp/drb_detach.#{pid}'
+#
+# Use single quotes to embed variables to be filled in later.
+#
+# Available variables:
+# * pid      The process id of the detached process
+#
+#
+# :allrefs - Controls how objects are passed to and from the
+# detached process. If :allrefs is set to true, all objects
+# passed back and forth from the remote object are only
+# passed as references, so that the original executing context
+# (ie. process) is always used. This option defaults to true
+# because it is the expect operating procedure.
+# 
+# The use of this option takes pains to allow objects you would
+# always expect to be Marshalled to still be Marshalled, such as
+# Symbol, String, Fixnum, Bignum, Array, etc.
+# 
+# NOTE: if you have problems with objects passed to detached
+# objects executing there methods in the detached process, and
+# you want them executed in the original context, try including
+# Drb::Undumped in your object rather then using this.
+#
+# :background - Controls how methods are dispatch on the detached
+# object. If :background is true, then all method calls are done
+# non-blocking, and a place holder object is returned. When
+# that place holder object has it's methods called, it blocks,
+# waiting for the real method operation to finish.
+    def detach(cfg={})
+        cfg = {
+            :ps => :append,
+            :die => :parent,
+            :name => :parent,
+            :id => :object,
+            :path => '/tmp/drb_detach.#{pid}',
+            :allref => true,
+            :background => true
+        }.merge(cfg)
+
+        if cfg[:name] == :parent
+            name = $0
+        else
+            name = cfg[:name].to_s
+        end
+
+        if cfg[:id] == :object
+            id = "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+        else
+            id = cfg[:id]
+        end
+
+        pid = fork {
+            # A nice little trick
+            case cfg[:ps]
+            when :append
+                $0 = name + " - #{id}"
+            when :replace
+                $0 = id
+            when :none
+                break
+            end
+            
+            if cfg[:ps].kind_of? String
+                $0 = cfg[:ps]
+            end
+
+            trap("INT") {
+                exit
+            }
+
+            pid = Process.pid
+
+            obj = nil
+            if cfg[:background] == true
+                obj = Dispatch::BackgroundDispatch.new(self,true)
+            else
+                obj = self
+            end
+            
+            DRb.start_service("drbunix://"+eval(%!"#{cfg[:path]}"!),obj)
+            DRb.thread.join
+            exit
+        }
+
+        # Mom always said I should clean up after myself
+
+        if cfg[:die] == :parent
+            at_exit {
+                Process.kill("INT", pid)
+            }
+        end
+        
+        sleep 0.3
+        DRb.start_service
+        remote = DRbObject.new(nil,"drbunix://"+eval(%!"#{cfg[:path]}"!))
+        if cfg[:allref] == true
+            remote.instance_eval "alias :real_method_missing :method_missing"
+
+            def remote.method_missing(msg_id, *a, &b)
+                a.each do |i|
+                    allow = true
+                    [Symbol, String, Fixnum, Bignum, Array, Regexp].each do |t|
+                        if i.kind_of? t
+                            allow = false
+                            break
+                        end
+                    end
+                    next if not allow
+                    def i._dump(d)
+                        raise TypeError, 'can\'t dump'
+                    end
+                end
+                return real_method_missing(msg_id, *a)
+            end
+        end
+
+        return remote
+    end
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  # fixture
+
+  class Logger
+    def log(str)
+        puts "From #{Process.pid}: #{str.to_s}"
+    end
+  end
+
+  class Person
+    attr_accessor :log
+    def say(msg)
+      puts "Detached #{Process.pid}"
+      @log.log("hello, i said #{msg}")
+    end
+    def wait
+      sleep 10
+      "hi"
+    end
+  end
+
+
+  class TC_Detach < Test::Unit::TestCase
+
+    puts "Parent is #{Process.pid}"
+
+    log = Logger.new
+    p = Person.new
+    p = p.detach(:allref => true)
+    puts "p is a #{p.class}"
+    p.log = log
+    p.say("I won!")
+
+    s = p.wait
+
+    puts "s is a #{s.class}"
+
+    puts "While i'm here, the other process should be doing it's thing."
+    puts "It's waiting for 10 seconds, so if i wait for 5, it should only be another 5 after i ask for the method that it returns"
+    sleep 5
+
+    puts "Lets try something..."
+    while not s.ready?
+        puts "Is the method ready? (#{s.ready?})"
+        sleep 2
+    end
+    p s.to_s
+
+    puts "Stats:"
+    p s.stats
+
+  end
+
+=end