facets 1.8.49 → 1.8.51

data/work/more/commandrunner.rb

@@ -1,101 +0,0 @@
-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

@@ -1,70 +0,0 @@
-#
-# 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

@@ -1,167 +0,0 @@
-###############################
-# 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

@@ -1,423 +0,0 @@
-=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