rubish 0.0.1

data/lib/rubish/executable.rb

@@ -0,0 +1,251 @@
+class Rubish::Executable
+
+  class ExecutableIO
+    class << self
+      # transactionally open a bunch of ios
+      # if one fails to open, close all others.
+      def ios(*specs)
+        success = false
+        begin
+          exe_ios = []
+          specs.each do |(spec,mode)|
+            exe_ios << prepare_io(spec,mode)
+          end
+          success =true
+          return exe_ios
+        ensure
+          unless success
+            exe_ios.each { |exe_io|
+              exe_io.close
+            }
+          end
+        end
+      end
+      
+      private
+      # sorry, this is pretty hairy. This method
+      # instructs how exec should handle IO. (whether
+      # IO is done in a thread. whether it needs to be
+      # closed. (so on))
+      #
+      # an io could be
+      # String: interpreted as file name
+      # Number: file descriptor
+      # IO: Ruby IO object
+      # Block: executed in a thread, and a pipe connects the executable and the thread.
+      def prepare_io(io,mode)
+        # if the io given is a block, we execute it in a thread (passing it a pipe)
+        raise "invalid io mode: #{mode}" unless mode == "w" || mode == "r"
+        result =
+          case io
+          when $stdin, $stdout, $stderr
+            [io, false, nil]
+          when String
+            path = File.expand_path(io)
+            raise "path is a directory" if File.directory?(path)
+            [File.new(path,mode), true, nil]
+          when IO
+            [io, false,nil] 
+          when Proc
+            proc = io
+            r,w = IO.pipe
+            # if we want to use a block to
+            # (1) input into executable
+            #   - return "r" end from prepare_io, and
+            #   the executable use this and standard
+            #   input.
+            #   - let the thread block writes to the "w" end
+            # (2) read from executable
+            #   - return "w" from prepare_io
+            #   - let thread reads from "r"
+            return_io, thread_io =
+              case mode
+                # case 1
+              when "r"
+                [r,w]
+              when "w"
+                # case 2
+                [w,r]
+              end
+            thread = Thread.new do
+            begin
+              proc.call(thread_io)
+            ensure
+              thread_io.close
+            end
+          end
+            [return_io, true, thread]
+          else
+            raise "not a valid input: #{io}"
+          end
+        return self.new(*result)
+      end
+
+    end
+
+    attr_reader :thread
+    attr_reader :io
+    attr_reader :auto_close
+    
+    def initialize(io,auto_close,thread)
+      @io = io
+      @auto_close = auto_close
+      @thread = thread
+    end
+
+    def close
+      if auto_close
+        io.close
+      else
+        #io.flush if io.stat.writable?
+        #io.flush rescue true # try flushing
+      end
+      if thread
+        begin
+          thread.join
+        ensure
+          if thread.alive?
+            thread.kill
+          end
+        end
+      end
+    end
+  end
+
+  
+  
+  attr_reader :working_directory
+
+  # only changes working directory for this executable
+  def cd(dir)
+    @working_directory = dir
+    self
+  end
+
+  def awk(a=nil,b=nil,&block)
+    if block
+      Rubish::Awk.new(self).act(a,b,&block)
+    else
+      Rubish::Awk.new(self)
+    end
+  end
+
+  def sed(a=nil,b=nil,&block)
+    if block
+      Rubish::Sed.new(self).act(a,b,&block)
+    else
+      Rubish::Sed.new(self)
+    end
+  end
+
+  def exec
+    raise "abstract"
+  end
+
+  def exec!
+    raise "abstract"
+  end
+
+  # methods for io redirection
+  def i(io=nil,&block)
+    return @__io_in unless io || block
+    @__io_in = io || block
+    self
+  end
+
+  def o(io=nil,&block)
+    return @__io_out unless io || block
+    @__io_out = io || block
+    self
+  end
+
+  def err(io=nil,&block)
+    return @__io_err unless io || block
+    @__io_err = io || block
+    self
+  end
+  
+  def io(i=nil,o=nil)
+    i(i); o(o)
+    self
+  end
+
+  def i=(io)
+    @__io_in = io
+  end
+
+  def o=(io)
+    @__io_out = io
+  end
+
+  def err=(io)
+    @__io_err = io
+  end
+
+  def each!
+    self.o do |pipe|
+      pipe.each_line do |line|
+        line.chomp!
+        yield(line)
+      end
+    end
+    job = self.exec!
+    return job
+  end
+
+  def each(&block)
+    job = self.each! &block
+    job.wait
+  end
+  
+  # acc is the accumulator passed in by reference, and updated destructively.
+  def map!(acc,&block)
+    acc = Array.new unless acc
+    job = self.each! do |l|
+      acc << (block.nil? ? l : block.call(l))
+    end
+    return job
+  end
+
+  def map(&block)
+    acc = []
+    job = self.map!(acc,&block)
+    job.wait
+    return acc
+  end
+
+  def head(n=1,&block)
+    raise "n should be greater than 0: #{n}" unless n > 0
+    self.map do |l|
+      if n == 0
+        break
+      else
+        n -= 1
+        block ? block.call(l) : l
+      end
+    end
+  end
+
+  def tail(n=1,&block)
+    raise "n should be greater than 0: #{n}" unless n > 0
+    acc = []
+    self.each do |l|
+      acc << (block ? block.call(l) : l)
+      if acc.size > n
+        acc.shift
+      end
+    end
+    return acc
+  end
+
+  def first
+    head(1).first
+  end
+
+  def last
+    tail(1).first
+  end
+
+  
+  
+end

data/lib/rubish/job.rb

@@ -0,0 +1,90 @@
+
+# a job is not necessarily registered with job control.
+class Rubish::Job
+  class Failure < Rubish::Error
+    attr_reader :job, :reason
+    def initialize(job,reason=nil)
+      raise "failure reason should be an Exception" unless reason.is_a?(Exception)
+      @job = job
+      @reason = reason
+      set_backtrace(reason.backtrace)
+    end
+
+    def to_s
+      @reason.to_s
+    end
+  end
+
+  attr_accessor :result
+  attr_reader :job_control
+
+  # subclass initializer MUST call __start
+  def initialize(*args)
+    raise "abstract"
+    __start
+  end
+
+  def __start
+    @result = nil
+    @done = false
+    # when wait is called, the job control may or
+    # may not be the current job_control.
+    @job_control = Rubish::JobControl.current 
+    @job_control.submit(self)
+    self
+  end
+
+  def __finish
+    @job_control.remove(self)
+    @done = true
+    self
+  end
+
+  # MUST call __finish in wait
+  # should return Job#result
+  def wait
+    raise "abstract"
+    __finish
+  end
+
+  # MUST result in calling __finish
+  def stop
+    raise "abstract"
+  end
+
+  def done?
+    @done
+  end
+  
+end
+
+# carry out some computation in a thread.
+class Rubish::Job::ThreadJob < Rubish::Job
+  attr_reader :thread
+  def initialize(&block)
+    # run block in a thread
+    @thread = ::Thread.new {
+      block.call
+    }
+    __start
+  end
+
+  def wait
+    # wait thread to completeggg64
+    begin
+      @thread.join
+      @result = @thread.value
+      return self.result
+    rescue => e
+      raise Rubish::Job::Failure.new(self,e)
+    ensure
+      __finish
+    end
+  end
+
+  def stop
+    @thread.kill
+    wait
+  end
+  
+end

data/lib/rubish/job_control.rb

@@ -0,0 +1,62 @@
+
+# A job is not necessarily registered with job
+# control.
+
+# TODO extend this for bg/fg (maybe?)
+# Assume that job control is used by a single thread...
+
+require 'thread'
+class Rubish::JobControl
+
+  class << self
+    def current
+      Rubish::Context.current.job_control
+    end
+  end
+
+  def initialize
+    @mutex = Mutex.new
+    @jobs = { }
+  end
+
+  def jobs
+    @jobs.values
+  end
+
+  # need to synchronize access to the jobs hash
+  def submit(job)
+    raise "expects a Rubish::JobControl::Job" unless job.is_a?(Rubish::Job)
+    @mutex.synchronize {
+      @jobs[job.object_id] = job
+    }
+  end
+
+  def remove(job)
+    raise "expects a Rubish::JobControl::Job" unless job.is_a?(Rubish::Job)
+    raise Rubish::Error.new("Job not found: #{job}") unless @jobs.include?(job.object_id)
+    @mutex.synchronize {
+      @jobs.delete(job.object_id)
+    }
+  end
+
+  def wait(*jobs)
+    rss = jobs.map do |job|
+      job.wait
+      if block_given?
+        yield(job)
+      else
+        job
+      end
+    end
+    return *rss
+  end
+
+  # TODO handle interrupt
+  def waitall(&block)
+    wait(*@jobs.values,&block)
+  end
+  
+  
+end
+
+

data/lib/rubish/pipe.rb

@@ -0,0 +1,68 @@
+
+class Rubish::Pipe < Rubish::UnixExecutable
+  attr_reader :cmds
+
+  class << self
+    def build(workspace=nil,&block)
+      workspace ||= Rubish::Context.current.workspace
+      cmds = []
+      workspace.command_factory_hook = Proc.new { |cmd| cmds << cmd; cmd}
+      workspace.eval &block
+      self.new(cmds)
+    end
+  end
+  
+  
+  def initialize(cmds)
+    # dun wanna handle special case for now
+    raise "pipe length less than 2" if cmds.length < 2
+    raise "should build pipe only from Rubish::Command instances" unless cmds.all? { |c| c.is_a?(Rubish::Command)}
+    @cmds = cmds
+  end
+
+  def exec_with(pipe_in,pipe_out,pipe_err)
+    @cmds.each do |cmd|
+      cmd.normalize_args!
+      if cmd.i || cmd.o || cmd.err
+        raise "It's weird to redirect stdioe for command in a pipeline. Don't."
+      end
+    end
+    # pipes == [i0,o1,i1,o2,i2...in,o0]
+    # i0 == $stdin
+    # o0 == $stdout
+    pipe = nil # [r, w]
+    pids = []
+    @cmds.each_index do |index|
+      tail = index == (@cmds.length - 1) # tail
+      head = index == 0 # head
+      if head
+        i = pipe_in
+        pipe = IO.pipe
+        o = pipe[1] # w
+      elsif tail
+        i = pipe[0]
+        o = pipe_out
+      else # middle
+        i = pipe[0] # r
+        pipe = IO.pipe
+        o = pipe[1]
+      end
+
+      cmd = @cmds[index]
+      if child = fork # children
+        #parent
+        pids << child
+        # it's important to close the pipes held
+        # by spawning parent, otherwise the pipes
+        # would not close after a program ends.
+        i.close unless head
+        o.close unless tail
+      else
+        # Rubish.set_stdioe((cmd.i || i),(cmd.o || o),(cmd.err || pipe_err))
+        cmd.system_exec(i,o,pipe_err)
+      end
+    end
+    return pids
+  end
+  
+end