Shazburg-webby 0.9.0

data/lib/webby/stelan/mktemp.rb

@@ -0,0 +1,135 @@
+# :stopdoc:
+# Skeleton module for the 'mktemp' routine.
+#
+# Ideally, one would do this in their code to import the "mktemp" call
+# directly into their current namespace:
+#
+#     require 'mktemp'
+#     include MkTemp
+#     # do something with mktemp()
+#
+#
+# It is recommended that you look at the documentation for the mktemp()
+# call directly for specific usage.
+#
+#--
+#
+# The compilation of software known as mktemp.rb is distributed under the
+# following terms:
+# Copyright (C) 2005-2006 Erik Hollensbe. All rights reserved.
+#
+# Redistribution and use in source form, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+#++
+
+module Webby
+module MkTemp
+  VALID_TMPNAM_CHARS = (?a..?z).to_a + (?A..?Z).to_a
+
+  #
+  # This routine just generates a temporary file similar to the
+  # routines from 'mktemp'. A trailing series of 'X' characters will
+  # be transformed into a randomly-generated set of alphanumeric
+  # characters.
+  # 
+  # This routine performs no file testing, at all. It is not suitable
+  # for anything beyond that.
+  #
+  
+  def tmpnam(filename)
+    m = filename.match(/(X*)$/)
+    
+    retnam = filename.dup
+    
+    if m[1]
+      mask = ""
+      m[1].length.times { mask += VALID_TMPNAM_CHARS[rand(52)].chr }
+      retnam.sub!(/(X*)$/, mask) 
+    end
+
+    return retnam
+  end
+  
+  module_function :tmpnam
+
+  #
+  # This routine works similarly to mkstemp(3) in that it gets a new
+  # file, and returns a file handle for that file. The mask parameter
+  # determines whether or not to process the filename as a mask by
+  # calling the tmpnam() routine in this module. This routine will
+  # continue until it finds a valid filename, which may not do what
+  # you expect.
+  #
+  # While all attempts have been made to keep this as secure as
+  # possible, due to a few problems with Ruby's file handling code, we
+  # are required to allow a few concessions. If a 0-length file is
+  # created before we attempt to create ours, we have no choice but to
+  # accept it. Do not rely on this code for any expected level of
+  # security, even though we have taken all the measures we can to
+  # handle that situation.
+  #
+
+  def mktemp(filename, mask=true)
+    fh = nil
+
+    begin 
+      loop do
+        fn = mask ? tmpnam(filename) : filename
+
+        if File.exist? fn
+          fail "Unable to create a temporary filename" unless mask
+          next
+        end
+
+        fh = File.new(fn, "a", 0600)
+        fh.seek(0, IO::SEEK_END)
+        break if fh.pos == 0 
+  
+        fail "Unable to create a temporary filename" unless mask
+        fh.close
+      end
+    rescue Exception => e
+      # in the case that we hit a locked file...
+      fh.close if fh
+      raise e unless mask
+    end
+    
+    return fh
+  end
+
+  module_function :mktemp
+
+  # 
+  # Create a directory. If mask is true (default), it will use the
+  # random name generation rules from the tmpnam() call in this
+  # module.
+  #
+ 
+  def mktempdir(filename, mask=true)
+    fn = mask ? tmpnam(filename) : filename
+    Dir.mkdir(fn)
+    return fn
+  end
+
+  module_function :mktempdir
+end  # module MkTemp
+end  # module Webby
+
+# :startdoc:
+# EOF

data/lib/webby/stelan/paginator.rb

@@ -0,0 +1,150 @@
+# This code was originally written by Bruce Williams, and it is available
+# as the Paginator gem. I've added a few helper methods and modifications so
+# it plays a little more nicely with Webby. Specifically, a Webby::Resource
+# can be given to the Page and used to generate links to the previous and
+# next pages.
+#
+# Many thanks to Bruce Williams for letting me use his work. Drop him a note
+# of praise scribbled on the back of a $100 bill. He'd appreciate it.
+
+require 'forwardable'
+
+module Webby
+class Paginator
+  
+  include Enumerable
+
+  class ArgumentError < ::ArgumentError; end
+  class MissingCountError < ArgumentError; end
+  class MissingSelectError < ArgumentError; end  
+  
+  attr_reader :per_page, :count, :resource
+  
+  # Instantiate a new Paginator object
+  #
+  # Provide:
+  # * A total count of the number of objects to paginate
+  # * The number of objects in each page
+  # * A block that returns the array of items
+  #   * The block is passed the item offset 
+  #     (and the number of items to show per page, for
+  #     convenience, if the arity is 2)
+  def initialize(count, per_page, resource, &select)
+    @count, @per_page, @resource = count, per_page, resource
+    unless select
+      raise MissingSelectError, "Must provide block to select data for each page"
+    end
+    @select = select
+  end
+  
+  # Total number of pages
+  def number_of_pages
+     (@count / @per_page).to_i + (@count % @per_page > 0 ? 1 : 0)
+  end
+  
+  # First page object
+  def first
+    page 1
+  end
+  
+  # Last page object
+  def last
+    page number_of_pages
+  end
+  
+  def each
+    1.upto(number_of_pages) do |number|
+      yield page(number)
+    end
+  end
+  
+  # Retrieve page object by number
+  def page(number)
+    number = (n = number.to_i) > 0 ? n : 1
+    Page.new(self, number, lambda { 
+      offset = (number - 1) * @per_page
+      args = [offset]
+      args << @per_page if @select.arity == 2
+      @select.call(*args)
+    })
+  end
+  
+  # Page object
+  #
+  # Retrieves items for a page and provides metadata about the position
+  # of the page in the paginator
+  class Page
+    
+    include Enumerable
+        
+    attr_reader :number, :pager, :url
+    
+    def initialize(pager, number, select) #:nodoc:
+      @pager, @number = pager, number
+      @offset = (number - 1) * pager.per_page
+      @select = select
+
+      @pager.resource.number = (number == 1 ? nil : number)
+      @url = @pager.resource.url
+    end
+
+    # Retrieve the items for this page
+    # * Caches
+    def items
+      @items ||= @select.call
+    end
+    
+    # Checks to see if there's a page before this one
+    def prev?
+      @number > 1
+    end
+    
+    # Get previous page (if possible)
+    def prev
+      @pager.page(@number - 1) if prev?
+    end
+     
+    # Checks to see if there's a page after this one
+    def next?
+      @number < @pager.number_of_pages
+    end
+     
+    # Get next page (if possible)
+    def next
+      @pager.page(@number + 1) if next?
+    end
+     
+    # The "item number" of the first item on this page
+    def first_item_number
+      1 + @offset
+    end
+     
+    # The "item number" of the last item on this page
+    def last_item_number
+      if next?
+        @offset + @pager.per_page
+      else
+        @pager.count
+      end
+    end
+     
+    def ==(other) #:nodoc:
+      @pager == other.pager && self.number == other.number
+    end
+     
+    def each(&block)
+      items.each(&block)
+    end
+     
+    def method_missing(meth, *args, &block) #:nodoc:
+      if @pager.respond_to?(meth)
+        @pager.__send__(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+  end
+  
+end  # class Paginator
+end  # module Webby

data/lib/webby/stelan/spawner.rb

@@ -0,0 +1,339 @@
+require 'rbconfig'
+require 'thread'
+require 'tempfile'
+
+# :stopdoc:
+
+# == Synopsis
+#
+# A class for spawning child processes and ensuring those children continue
+# running.
+#
+# == Details
+#
+# When a spawner is created it is given the command to run in a child
+# process. This child process has +stdin+, +stdout+, and +stderr+ redirected
+# to +/dev/null+ (this works even on Windows). When the child dies for any
+# reason, the spawner will restart a new child process in the exact same
+# manner as the original.
+#
+class Spawner
+
+  @dev_null = test(?e, "/dev/null") ? "/dev/null" : "NUL:"
+
+  c = ::Config::CONFIG
+  ruby = File.join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+  @ruby = if    system('%s -e exit' % ruby) then ruby
+          elsif system('ruby -e exit')      then 'ruby' 
+          else  warn 'no ruby in PATH/CONFIG'
+          end
+
+  class << self
+    attr_reader :ruby
+    attr_reader :dev_null
+
+    def finalizer( cids )
+      pid = $$
+      lambda do
+        break unless pid == $$
+        cids.kill 'TERM', :all
+      end  # lambda
+    end  # finalizer
+  end
+
+  # call-seq:
+  #    Spawner.new( command, *args, opts = {} )
+  #
+  # Creates a new spawner that will execute the given external _command_ in
+  # a sub-process. The calling semantics of <code>Kernel::exec</code> are
+  # used to execute the _command_. Any number of optional _args_ can be
+  # passed to the _command_.
+  #
+  # Available options:
+  #
+  #    :spawn   => the number of child processes to spawn
+  #    :pause   => wait time (in seconds) before respawning after termination
+  #    :ruby    => the Ruby interpreter to use when spawning children
+  #    :env     => a hash for the child process environment
+  #    :stdin   => stdin child processes will read from
+  #    :stdout  => stdout child processes will write to
+  #    :stderr  => stderr child processes will write to
+  #
+  # The <code>:env</code> option is used to add environemnt variables to
+  # child processes when they are spawned.
+  #
+  # *Note:* all spawned child processes will use the same stdin, stdout, and
+  # stderr if they are given in the options. Otherwise they all default to
+  # <code>/dev/null</code> on *NIX and <code>NUL:</code> on Windows.
+  #
+  def initialize( *args )
+    config = {
+      :ruby => self.class.ruby,
+      :spawn => 1,
+      :pause => 0,
+      :stdin => self.class.dev_null,
+      :stdout => self.class.dev_null,
+      :stderr => self.class.dev_null
+    }
+    config.merge! args.pop if Hash === args.last
+    config[:argv] = args
+
+    raise ArgumentError, 'wrong number of arguments' if args.empty?
+
+    @stop = true
+    @cids = []
+    @group = ThreadGroup.new
+
+    @spawn = config.delete(:spawn)
+    @pause = config.delete(:pause)
+    @ruby = config.delete(:ruby)
+
+    @tmp = child_program(config)
+
+    class << @cids
+      # call-seq:
+      #    sync {block}
+      #
+      # Executes the given block in a synchronized fashion -- i.e. only a
+      # single thread can execute at a time. Uses Mutex under the hood.
+      #
+      def sync(&b) 
+        @mutex ||= Mutex.new
+        @mutex.synchronize(&b)
+      end
+
+      # call-seq:
+      #    kill( signal, num )     => number killed
+      #    kill( signal, :all )    => number killed
+      #
+      # Send the _signal_ to a given _num_ of child processes or all child
+      # processes if <code>:all</code> is given instead of a number. Returns
+      # the number of child processes killed.
+      #
+      def kill( signal, arg )
+        return if empty?
+
+        ary = sync do
+                case arg
+                when :all; self.dup
+                when Integer; self.slice(0,arg)
+                else raise ArgumentError end
+              end
+
+        ary.each do |cid|
+          begin
+            Process.kill(signal, cid)
+          rescue SystemCallError
+            sync {delete cid}
+          end
+        end
+        ary.length
+      end  # def kill
+    end  # class << @cids
+
+  end  # def initialize
+
+  attr_reader :spawn
+  attr_accessor :pause
+
+  # call-seq:
+  #    spawner.spawn = num
+  #
+  # Set the number of child processes to spawn. If the new spawn number is
+  # less than the current number, then spawner threads will die 
+  #
+  def spawn=( num )
+    num = num.abs
+    diff, @spawn = num - @spawn, num
+    return unless running?
+
+    if diff > 0
+      diff.times {_spawn}
+    elsif diff < 0
+      @cids.kill 'TERM', diff.abs
+    end
+  end
+
+  # call-seq:
+  #    start    => self
+  #
+  # Spawn the sub-processes.
+  #
+  def start
+    return self if running?
+    @stop = false
+
+    @cleanup = Spawner.finalizer(@cids)
+    ObjectSpace.define_finalizer(self, @cleanup)
+
+    @spawn.times {_spawn}
+    self
+  end
+
+  # call-seq:
+  #    stop( timeout = 5 )    => self
+  #
+  # Stop any spawned sub-processes.
+  #
+  def stop( timeout = 5 )
+    return self unless running?
+    @stop = true
+
+    @cleanup.call
+    ObjectSpace.undefine_finalizer(self)
+
+    # the cleanup call sends SIGTERM to all the child processes
+    # however, some might still be hanging around, so we are going to wait
+    # for a timeout interval and then send a SIGKILL to any remaining child
+    # processes
+    nap_time = 0.05 * timeout   # sleep for 5% of the timeout interval
+    timeout = Time.now + timeout
+
+    until @cids.empty?
+      sleep nap_time
+      unless Time.now < timeout
+        @cids.kill 'KILL', :all
+        @cids.clear
+        @group.list.each {|t| t.kill}
+        break
+      end
+    end
+
+    self
+  end
+
+  # call-seq:
+  #    restart( timeout = 5 )
+  #
+  def restart( timeout = 5 )
+    stop( timeout )
+    start
+  end
+
+  # call-seq:
+  #    running?
+  #
+  # Returns +true+ if the spawner is currently running; returns +false+
+  # otherwise.
+  #
+  def running?
+    !@stop
+  end
+
+  # call-seq:
+  #    join( timeout = nil )    => spawner or nil
+  #
+  # The calling thread will suspend execution until all child processes have
+  # been stopped. Does not return until all spawner threads have exited (the
+  # child processes have been stopped) or until _timeout seconds have
+  # passed. If the timeout expires +nil+ will be returned; otherwise the
+  # spawner is returned.
+  #
+  def join( limit = nil )
+    loop do
+      t = @group.list.first
+      break if t.nil?
+      return nil unless t.join(limit)
+    end
+    self
+  end
+
+
+  private
+
+  # call-seq:
+  #    _spawn    => thread
+  #
+  # Creates a thread that will spawn the sub-process via
+  # <code>IO::popen</code>. If the sub-process terminates, it will be
+  # respawned until the +stop+ message is sent to this spawner.
+  #
+  # If an Exception is encountered during the spawning process, a message
+  # will be printed to stderr and the thread will exit.
+  #
+  def _spawn
+    t = Thread.new do
+          catch(:die) do
+            loop do
+              begin
+                io = IO.popen("#{@ruby} #{@tmp.path}", 'r')
+                cid = io.gets.to_i
+
+                @cids.sync {@cids << cid} if cid > 0
+                Process.wait cid
+              rescue Exception => e
+                STDERR.puts e.inspect
+                STDERR.puts e.backtrace.join("\n")
+                throw :die
+              ensure
+                io.close rescue nil
+                @cids.sync {
+                  @cids.delete cid
+                  throw :die unless @cids.length < @spawn
+                }
+              end
+
+              throw :die if @stop
+              sleep @pause
+
+            end  # loop
+          end  # catch(:die)
+        end  # Thread.new
+
+    @group.add t
+    t
+  end
+
+  # call-seq:
+  #    child_program( config )    => tempfile
+  #
+  # Creates a child Ruby program based on the given _config_ hash. The
+  # following hash keys are used:
+  #
+  #    :argv    => command and arguments passed to <code>Kernel::exec</code>
+  #    :env     => environment variables for the child process
+  #    :cwd     => the current working directory to use for the child process
+  #    :stdin   => stdin the child process will read from
+  #    :stdout  => stdout the child process will write to
+  #    :stderr  => stderr the child process will write to
+  #
+  def child_program( config )
+    config = Marshal.dump(config)
+
+    tmp = Tempfile.new(self.class.name.downcase)
+    tmp.write <<-PROG
+      begin
+        config = Marshal.load(#{config.inspect})
+
+        argv = config[:argv]
+        env = config[:env]
+        cwd = config[:cwd]
+        stdin = config[:stdin]
+        stdout = config[:stdout]
+        stderr = config[:stderr]
+
+        Dir.chdir cwd if cwd
+        env.each {|k,v| ENV[k.to_s] = v.to_s} if env
+      rescue Exception => e
+        STDERR.warn e
+        abort
+      end
+
+      STDOUT.puts Process.pid
+      STDOUT.flush
+
+      STDIN.reopen stdin
+      STDOUT.reopen stdout
+      STDERR.reopen stderr
+
+      exec *argv
+    PROG
+
+    tmp.close
+    tmp
+  end
+end  # class Spawner
+
+# :startdoc:
+
+# EOF