session 2.4.0 → 3.1.0

data/sample/bash.rb.out

@@ -0,0 +1,51 @@
+======== ======== ======== ========
+#1
+======== ======== ======== ========
+STDOUT:
+README
+install.rb
+lib
+sample
+STDERR:
+STATUS: 0
+======== ======== ======== ========
+======== ======== ======== ========
+#2
+======== ======== ======== ========
+STDOUT:
+README
+STDERR:
+STDOUT:
+install.rb
+STDERR:
+STDOUT:
+lib
+STDERR:
+STDOUT:
+sample
+STDERR:
+STATUS: 0
+======== ======== ======== ========
+======== ======== ======== ========
+#3
+======== ======== ======== ========
+STDOUT:
+README
+install.rb
+lib
+sample
+STDERR:
+STATUS: 0
+======== ======== ======== ========
+======== ======== ======== ========
+#4
+======== ======== ======== ========
+42
+42
+42
+42
+42
+42
+42
+42
+... (repeats forever)

data/sample/driver.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'logger'
+$:.unshift '.', '..', 'lib', File.join('..','lib')
+require 'session'
+
+DIV = ('=' * 79) << "\n"
+
+
+# start session with bash
+bash = Session::Bash.new
+
+
+# create two tempory external programs to drive
+prog_a = Tempfile.new('prog_a_')
+prog_a.write <<-code
+  puts $0
+  puts 42
+code
+prog_a.close
+prog_a = prog_a.path
+
+prog_b = Tempfile.new('prog_b_')
+prog_b.write <<-code
+  puts $0
+  puts 'forty-two' 
+code
+prog_b.close
+prog_b = prog_b.path
+
+
+# set up logging
+logger = Logger.new STDOUT
+
+
+# run both programs redirect the stdout into the log
+logger.info{ 'running program a' }
+logger << DIV
+bash.execute "ruby #{ prog_a}", :stdout => logger, :stderr => STDERR
+logger << DIV
+
+logger.info{ 'running program b' }
+logger << DIV
+bash.execute "ruby #{ prog_b}", :stdout => logger, :stderr => STDERR
+logger << DIV
+
+

data/sample/session_idl.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'readline'
+include Readline
+
+$:.unshift '.', '..', 'lib', File.join('..','lib')
+require 'session'
+
+idl = Session::IDL.new
+
+n = 0
+loop do
+  command = readline("#{ n }: IDL_WRAP > ", true) 
+  if command =~ /^\s*\!*history\!*\s*$/
+    open('idl_wrap.history','w'){|f| f.puts idl.history}
+    next
+  end
+  exit if command =~ /^\s*exit\s*$/io
+
+  out, err = idl.execute command
+  out ||= ''
+  err ||= ''
+  printf "STDOUT:\n%s\nSTDERR:\n%s\n", out.gsub(%r/^/,"\t"), err.gsub(%r/^/,"\t")
+  n += 1
+end

data/sample/session_sh.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'readline'
+include Readline
+
+$:.unshift '.', '..', 'lib', File.join('..','lib')
+require 'session'
+
+shell = Session::Shell.new
+
+require 'tempfile'
+require 'readline'
+include Readline
+
+n = 0
+loop do
+  command = readline("#{ n }: SHELL > ", true) 
+  if command =~ /^\s*\!*history\!*\s*$/
+    open('shell.history','w'){|f| f.puts shell.history}
+    next
+  end
+  exit if command =~ /^\s*(?:exit|quit)\s*$/io
+
+  out, err = shell.execute command
+  out ||= ''
+  err ||= ''
+  printf "STDOUT:\n%s\nSTDERR:\n%s\n", out.gsub(%r/^/,"\t"), err.gsub(%r/^/,"\t")
+  n += 1
+end

data/sample/sh0.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+
+$:.unshift '.', '..', 'lib', File.join('..','lib')
+require 'session'
+
+shell = Session::Shell.new :history => false
+
+shell.execute('ls -ltar') do |out, err|
+  if out
+    puts "OUT:\n#{ out }"
+  elsif err
+    puts "ERR:\n#{ err }"
+  end
+end
+puts shell.history
+
+shell.outproc = lambda{|out| puts "OUT:\n#{ out }"}
+shell.errproc = lambda{|err| puts "ERR:\n#{ err }"}
+#shell.execute('ls -1')
+#shell.execute('ls no-exit')
+shell.execute('while test 1; do echo `date` && ls no-exist; sleep 1; done')
+

data/sample/stdin.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+$:.unshift '.', '..', 'lib', File.join('..','lib')
+require 'session'
+
+sh = Session::new
+
+stdout, stderr = sh.execute('cat', :stdin => open('/etc/passwd'))
+
+stdout.each{|line| print line}
+
+
+
+stdin, stdout, stderr = "42\n", '', ''
+
+sh.execute('cat', 0 => stdin, 1 => stdout, 2 => stderr)
+
+stdout.each{|line| print line}

data/sample/threadtest.rb

@@ -0,0 +1,42 @@
+# usage:
+# ruby -I lib -r session test/threadtest.rb
+# SESSION_USE_SPAWN=1 ruby -I lib -r session test/threadtest.rb
+
+%w(lib  ../lib . ..).each{|d| $:.unshift d}
+require 'session'
+
+def display obj 
+  Thread.critical = true
+  STDOUT.print obj
+  STDOUT.flush
+  ensure
+  Thread.critical = false
+end
+
+$VERBOSE=nil
+STDOUT.sync = true
+STDERR.sync = true
+STDOUT.puts "Session::VERSION <#{ Session::VERSION }>"
+STDOUT.puts "Session.use_spawn <#{ Session.use_spawn ? 'true' : 'false' }>"
+STDOUT.puts "the timestamps of each tid should come back about 1 second apart or there are problems..."
+STDOUT.puts
+
+
+threads = []
+
+3.times do |i|
+  threads << 
+    Thread::new(i) do |i| 
+      cmd = 'echo 42; sleep 1;' * 3      
+      sh = Session.new #:use_spawn=>true
+      sh.execute(cmd) do |o,e| 
+        which = o ? 'stdout' : 'stderr'
+        line = (o || e).strip
+        indent = '| ' * i
+        display "#{ indent }tid<#{ i }> #{ which }<#{ line }> time<#{ Time.now.to_f }>\n"
+      end
+    end
+  sleep rand
+end
+
+threads.map{|t| t.join}

data/session.gemspec

@@ -0,0 +1,27 @@
+## session.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "session"
+  spec.version = "3.1.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "session"
+  spec.description = "description: session kicks the ass"
+
+  spec.files = ["gemspec.rb", "lib", "lib/session.rb", "LICENSE", "Rakefile", "README", "sample", "sample/bash.rb", "sample/bash.rb.out", "sample/driver.rb", "sample/session_idl.rb", "sample/session_sh.rb", "sample/sh0.rb", "sample/stdin.rb", "sample/threadtest.rb", "session.gemspec", "test", "test/session.rb"]
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.has_rdoc = true
+  spec.test_files = "test/session.rb"
+  #spec.add_dependency 'lib', '>= version'
+  spec.add_dependency 'fattr'
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://github.com/ahoward/session/tree/master"
+end

data/test/session.rb

@@ -17,6 +17,9 @@ Session::debug = true
 class TimeoutError < StandardError; end
 def timeout n
 #{{{
+  # JRuby does not support fork, so we stub out timeout here
+  return yield if defined? JRUBY_VERSION
+
   ret = nil
   cid = fork 
   unless cid

metadata

@@ -1,41 +1,78 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
-specification_version: 1
 name: session
 version: !ruby/object:Gem::Version 
-  version: 2.4.0
-date: 2005-11-13 00:00:00.000000 -07:00
-summary: session
-require_paths: 
-  - lib
-email: ara.t.howard@noaa.gov
-homepage: http://codeforpeople.com/lib/ruby/session/
-rubyforge_project: 
-description: 
-autorequire: session
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
-  version: 
+  version: 3.1.0
 platform: ruby
-signing_key: 
-cert_chain: 
 authors: 
-  - Ara T. Howard
-files: 
-  - lib/session.rb
-  - lib/session-2.4.0.rb
-test_files: 
-  - test/session.rb
-rdoc_options: []
-extra_rdoc_files: []
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fattr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "description: session kicks the ass"
+email: ara.t.howard@gmail.com
 executables: []
+
 extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- gemspec.rb
+- lib/session.rb
+- LICENSE
+- Rakefile
+- README
+- sample/bash.rb
+- sample/bash.rb.out
+- sample/driver.rb
+- sample/session_idl.rb
+- sample/session_sh.rb
+- sample/sh0.rb
+- sample/stdin.rb
+- sample/threadtest.rb
+- session.gemspec
+- test/session.rb
+has_rdoc: true
+homepage: http://github.com/ahoward/session/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
-dependencies: []
+
+rubyforge_project: codeforpeople
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: session
+test_files: 
+- test/session.rb

data/lib/session-2.4.0.rb

@@ -1,744 +0,0 @@
-require 'open3'
-require 'tmpdir'
-require 'thread'
-require 'yaml'
-require 'tempfile'
-
-module Session 
-#--{{{
-  VERSION = '2.4.0'
-
-  @track_history = ENV['SESSION_HISTORY'] || ENV['SESSION_TRACK_HISTORY']
-  @use_spawn     = ENV['SESSION_USE_SPAWN']
-  @use_open3     = ENV['SESSION_USE_OPEN3']
-  @debug         = ENV['SESSION_DEBUG']
-
-  class << self
-#--{{{
-    attr :track_history, true
-    attr :use_spawn, true
-    attr :use_open3, true
-    attr :debug, true
-    def new(*a, &b)
-#--{{{
-      Sh::new(*a, &b)
-#--}}}
-    end
-    alias [] new
-#--}}}
-  end
-
-  class PipeError < StandardError; end
-  class ExecutionError < StandardError; end
-
-  class History
-#--{{{
-    def initialize; @a = []; end
-    def method_missing(m,*a,&b); @a.send(m,*a,&b); end
-    def to_yaml(*a,&b); @a.to_yaml(*a,&b); end
-    alias to_s to_yaml 
-    alias to_str to_yaml 
-#--}}}
-  end # class History
-  class Command
-#--{{{
-    class << self
-#--{{{
-      def cmdno; @cmdno ||= 0; end
-      def cmdno= n; @cmdno = n; end
-#--}}}
-    end
-
-    # attributes
-#--{{{
-    attr :cmd
-    attr :cmdno
-    attr :out,true
-    attr :err,true
-    attr :cid
-    attr :begin_out
-    attr :end_out
-    attr :begin_out_pat
-    attr :end_out_pat
-    attr :begin_err
-    attr :end_err
-    attr :begin_err_pat
-    attr :end_err_pat
-#--}}}
-
-    def initialize(command)
-#--{{{
-      @cmd = command.to_s
-      @cmdno = self.class.cmdno
-      self.class.cmdno += 1
-      @err = ''
-      @out = ''
-      @cid = "%d_%d_%d" % [$$, cmdno, rand(Time.now.usec)]
-      @begin_out = "__CMD_OUT_%s_BEGIN__" % cid
-      @end_out = "__CMD_OUT_%s_END__" % cid
-      @begin_out_pat = %r/#{ Regexp.escape(@begin_out) }/
-      @end_out_pat = %r/#{ Regexp.escape(@end_out) }/
-      @begin_err = "__CMD_ERR_%s_BEGIN__" % cid
-      @end_err = "__CMD_ERR_%s_END__" % cid
-      @begin_err_pat = %r/#{ Regexp.escape(@begin_err) }/
-      @end_err_pat = %r/#{ Regexp.escape(@end_err) }/
-#--}}}
-    end
-    def to_hash
-#--{{{
-      %w(cmdno cmd out err cid).inject({}){|h,k| h.update k => send(k) }
-#--}}}
-    end
-    def to_yaml(*a,&b)
-#--{{{
-      to_hash.to_yaml(*a,&b)
-#--}}}
-    end
-    alias to_s to_yaml 
-    alias to_str to_yaml 
-#--}}}
-  end # class Command
-  class AbstractSession 
-#--{{{
-
-  # class methods
-    class << self
-#--{{{
-      def default_prog
-#--{{{
-        return @default_prog if defined? @default_prog and @default_prog
-        if defined? self::DEFAULT_PROG
-          return @default_prog = self::DEFAULT_PROG 
-        else
-          @default_prog = ENV["SESSION_#{ self }_PROG"]
-        end
-        nil
-#--}}}
-      end
-      def default_prog= prog
-#--{{{
-        @default_prog = prog 
-#--}}}
-      end
-      attr :track_history, true
-      attr :use_spawn, true
-      attr :use_open3, true
-      attr :debug, true
-      def init
-#--{{{
-        @track_history = nil
-        @use_spawn = nil
-        @use_open3 = nil
-        @debug = nil
-#--}}}
-      end
-      alias [] new
-#--}}}
-    end
-
-  # class init
-    init
-
-  # attributes
-#--{{{
-    attr :opts
-    attr :prog
-    attr :stdin
-    alias i stdin
-    attr :stdout
-    alias o stdout
-    attr :stderr
-    alias e stderr
-    attr :history
-    attr :track_history
-    attr :outproc, true
-    attr :errproc, true
-    attr :use_spawn
-    attr :use_open3
-    attr :debug, true
-    alias debug? debug
-    attr :threads
-#--}}}
-
-  # instance methods
-    def initialize(*args)
-#--{{{
-      @opts = hashify(*args)
-
-      @prog = getopt('prog', opts, getopt('program', opts, self.class::default_prog))
-
-      raise(ArgumentError, "no program specified") unless @prog
-
-      @track_history = nil
-      @track_history = Session::track_history unless Session::track_history.nil?
-      @track_history = self.class::track_history unless self.class::track_history.nil?
-      @track_history = getopt('history', opts) if hasopt('history', opts) 
-      @track_history = getopt('track_history', opts) if hasopt('track_history', opts) 
-
-      @use_spawn = nil
-      @use_spawn = Session::use_spawn unless Session::use_spawn.nil?
-      @use_spawn = self.class::use_spawn unless self.class::use_spawn.nil?
-      @use_spawn = getopt('use_spawn', opts) if hasopt('use_spawn', opts)
-
-      @use_open3 = nil
-      @use_open3 = Session::use_open3 unless Session::use_open3.nil?
-      @use_open3 = self.class::use_open3 unless self.class::use_open3.nil?
-      @use_open3 = getopt('use_open3', opts) if hasopt('use_open3', opts) 
-
-      @debug = nil
-      @debug = Session::debug unless Session::debug.nil?
-      @debug = self.class::debug unless self.class::debug.nil?
-      @debug = getopt('debug', opts) if hasopt('debug', opts) 
-
-      @history = nil
-      @history = History::new if @track_history 
-
-      @outproc = nil
-      @errproc = nil
-
-      @stdin, @stdout, @stderr =
-        if @use_spawn
-          Spawn::spawn @prog
-        elsif @use_open3
-          Open3::popen3 @prog
-        else
-          __popen3 @prog
-        end
-
-      @threads = []
-
-      clear
-
-      if block_given?
-        ret = nil
-        begin
-          ret = yield self
-        ensure
-          self.close!
-        end
-        return ret
-      end
-
-      return self
-#--}}}
-    end
-    def getopt opt, hash, default = nil
-#--{{{
-      key = opt
-      return hash[key] if hash.has_key? key
-      key = "#{ key }"
-      return hash[key] if hash.has_key? key
-      key = key.intern
-      return hash[key] if hash.has_key? key
-      return default
-#--}}}
-    end
-    def hasopt opt, hash
-#--{{{
-      key = opt
-      return key if hash.has_key? key
-      key = "#{ key }"
-      return key if hash.has_key? key
-      key = key.intern
-      return key if hash.has_key? key
-      return false 
-#--}}}
-    end
-    def __popen3(*cmd)
-#--{{{
-      pw = IO::pipe   # pipe[0] for read, pipe[1] for write
-      pr = IO::pipe
-      pe = IO::pipe
-
-      pid =
-        __fork{
-          # child
-          pw[1].close
-          STDIN.reopen(pw[0])
-          pw[0].close
-
-          pr[0].close
-          STDOUT.reopen(pr[1])
-          pr[1].close
-
-          pe[0].close
-          STDERR.reopen(pe[1])
-          pe[1].close
-
-          exec(*cmd)
-        }
-
-      Process::detach pid   # avoid zombies
-
-      pw[0].close
-      pr[1].close
-      pe[1].close
-      pi = [pw[1], pr[0], pe[0]]
-      pw[1].sync = true
-      if defined? yield
-        begin
-          return yield(*pi)
-        ensure
-          pi.each{|p| p.close unless p.closed?}
-        end
-      end
-      pi
-#--}}}
-    end
-    def __fork(*a, &b)
-#--{{{
-      verbose = $VERBOSE
-      begin
-        $VERBOSE = nil 
-        Kernel::fork(*a, &b)
-      ensure
-        $VERBOSE = verbose
-      end
-#--}}}
-    end
-
-  # abstract methods
-    def clear
-#--{{{
-      raise NotImplementedError
-#--}}}
-    end
-    alias flush clear
-    def path 
-#--{{{
-      raise NotImplementedError
-#--}}}
-    end
-    def path= 
-#--{{{
-      raise NotImplementedError
-#--}}}
-    end
-    def send_command cmd
-#--{{{
-      raise NotImplementedError
-#--}}}
-    end
-
-  # concrete methods
-    def track_history= bool
-#--{{{
-      @history ||= History::new
-      @track_history = bool
-#--}}}
-    end
-    def ready?
-#--{{{
-      (stdin and stdout and stderr) and
-      (IO === stdin and IO === stdout and IO === stderr) and
-      (not (stdin.closed? or stdout.closed? or stderr.closed?))
-#--}}}
-    end
-    def close!
-#--{{{
-      [stdin, stdout, stderr].each{|pipe| pipe.close}
-      stdin, stdout, stderr = nil, nil, nil
-      true
-#--}}}
-    end
-    alias close close!
-    def hashify(*a)
-#--{{{
-      a.inject({}){|o,h| o.update(h)}
-#--}}}
-    end
-    private :hashify
-    def execute(command, redirects = {})
-#--{{{
-      $session_command = command if @debug
-
-      raise(PipeError, command) unless ready? 
-
-    # clear buffers
-      clear
-
-    # setup redirects
-      rerr = redirects[:e] || redirects[:err] || redirects[:stderr] || 
-             redirects['stderr'] || redirects['e'] || redirects['err'] ||
-             redirects[2] || redirects['2']
-
-      rout = redirects[:o] || redirects[:out] || redirects[:stdout] || 
-             redirects['stdout'] || redirects['o'] || redirects['out'] ||
-             redirects[1] || redirects['1']
-
-    # create cmd object and add to history
-      cmd = Command::new command.to_s
-
-    # store cmd if tracking history
-      history << cmd if track_history
-
-    # mutex for accessing shared data
-      mutex = Mutex::new
-
-    # io data for stderr and stdout 
-      err = {
-        :io        => stderr,
-        :cmd       => cmd.err,
-        :name      => 'stderr',
-        :begin     => false,
-        :end       => false,
-        :begin_pat => cmd.begin_err_pat,
-        :end_pat   => cmd.end_err_pat,
-        :redirect  => rerr,
-        :proc      => errproc,
-        :yield     => lambda{|buf| yield(nil, buf)},
-        :mutex     => mutex,
-      }
-      out = {
-        :io        => stdout,
-        :cmd       => cmd.out,
-        :name      => 'stdout',
-        :begin     => false,
-        :end       => false,
-        :begin_pat => cmd.begin_out_pat,
-        :end_pat   => cmd.end_out_pat,
-        :redirect  => rout,
-        :proc      => outproc,
-        :yield     => lambda{|buf| yield(buf, nil)},
-        :mutex     => mutex,
-      }
-
-    begin
-      # send command in the background so we can begin processing output
-      # immediately - thanks to tanaka akira for this suggestion
-        threads << Thread::new { send_command cmd }
-
-      # init 
-        main       = Thread::current
-        exceptions = []
-
-      # fire off reader threads
-        [err, out].each do |iodat|
-          threads <<
-            Thread::new(iodat, main) do |iodat, main|
-
-              loop do
-                main.raise(PipeError, command) unless ready? 
-                main.raise ExecutionError, iodat[:name] if iodat[:end] and not iodat[:begin]
-
-                break if iodat[:end] or iodat[:io].eof?
-
-                line = iodat[:io].gets
-
-                buf = nil
-
-                case line
-                  when iodat[:end_pat]
-                    iodat[:end] = true
-                  # handle the special case of non-newline terminated output
-                    if((m = %r/(.+)__CMD/o.match(line)) and (pre = m[1]))
-                      buf = pre
-                    end
-                  when iodat[:begin_pat]
-                    iodat[:begin] = true
-                  else
-                    next unless iodat[:begin] and not iodat[:end] # ignore chaff
-                    buf = line
-                end
-
-                if buf
-                  iodat[:mutex].synchronize do
-                    iodat[:cmd] << buf
-                    iodat[:redirect] << buf if iodat[:redirect]
-                    iodat[:proc].call buf  if iodat[:proc]
-                    iodat[:yield].call buf  if block_given?
-                  end
-                end
-              end
-
-              true
-          end
-        end
-      ensure
-      # reap all threads - accumulating and rethrowing any exceptions
-        begin
-          while((t = threads.shift))
-            t.join
-            raise ExecutionError, 'iodat thread failure' unless t.value
-          end
-        rescue => e
-          exceptions << e
-          retry unless threads.empty?
-        ensure
-          unless exceptions.empty?
-            meta_message = '<' << exceptions.map{|e| "#{ e.message } - (#{ e.class })"}.join('|') << '>'
-            meta_backtrace = exceptions.map{|e| e.backtrace}.flatten
-            raise ExecutionError, meta_message, meta_backtrace 
-          end
-        end
-      end
-
-    # this should only happen if eof was reached before end pat
-      [err, out].each do |iodat|
-        raise ExecutionError, iodat[:name] unless iodat[:begin] and iodat[:end]
-      end
-
-
-    # get the exit status
-      get_status if respond_to? :get_status
-
-      out = err = iodat = nil
-
-      return [cmd.out, cmd.err]
-#--}}}
-    end
-#--}}}
-  end # class AbstractSession
-  class Sh < AbstractSession
-#--{{{
-    DEFAULT_PROG    = 'sh'
-    ECHO            = 'echo'
-
-    attr :status
-    alias exit_status status
-    alias exitstatus status
-
-    def clear
-#--{{{
-      stdin.puts "#{ ECHO } __clear__ 1>&2"
-      stdin.puts "#{ ECHO } __clear__"
-      stdin.flush
-      while((line = stderr.gets) and line !~ %r/__clear__/o); end
-      while((line = stdout.gets) and line !~ %r/__clear__/o); end
-      self
-#--}}}
-    end
-    def send_command cmd
-#--{{{
-      stdin.printf "%s '%s' 1>&2\n", ECHO, cmd.begin_err
-      stdin.printf "%s '%s' \n", ECHO, cmd.begin_out
- 
-      stdin.printf "%s\n", cmd.cmd
-      stdin.printf "export __exit_status__=$?\n"
-
-      stdin.printf "%s '%s' 1>&2\n", ECHO, cmd.end_err
-      stdin.printf "%s '%s' \n", ECHO, cmd.end_out
- 
-      stdin.flush
-#--}}}
-    end
-    def get_status
-#--{{{
-      @status = get_var '__exit_status__' 
-      unless @status =~ /^\s*\d+\s*$/o
-        raise ExecutionError, "could not determine exit status from <#{ @status.inspect }>"
-      end
-
-      @status = Integer @status
-#--}}}
-    end
-    def set_var name, value
-#--{{{
-      stdin.puts "export #{ name }=#{ value }"
-      stdin.flush
-#--}}}
-    end
-    def get_var name
-#--{{{
-      stdin.puts "#{ ECHO } \"#{ name }=${#{ name }}\""
-      stdin.flush
-
-      var = nil
-      while((line = stdout.gets))
-        m = %r/#{ name }\s*=\s*(.*)/.match line
-        if m
-          var = m[1] 
-          raise ExecutionError, "could not determine <#{ name }> from <#{ line.inspect }>" unless var
-          break
-        end
-      end
-
-      var
-#--}}}
-    end
-    def path 
-#--{{{
-      var = get_var 'PATH'
-      var.strip.split %r/:/o
-#--}}}
-    end
-    def path= arg 
-#--{{{
-      case arg
-        when Array
-          arg = arg.join ':'
-        else
-          arg = arg.to_s.strip
-      end
-
-      set_var 'PATH', "'#{ arg }'"
-      self.path
-#--}}}
-    end
-    def execute(command, redirects = {}, &block)
-#--{{{
-    # setup redirect on stdin
-      rin = redirects[:i] || redirects[:in] || redirects[:stdin] || 
-             redirects['stdin'] || redirects['i'] || redirects['in'] ||
-             redirects[0] || redirects['0']
-
-      if rin
-        tmp = 
-          begin
-            Tempfile::new rand.to_s
-          rescue
-            Tempfile::new rand.to_s
-          end
-
-        begin
-          tmp.write(
-            if rin.respond_to? 'read'
-              rin.read
-            elsif rin.respond_to? 'to_s'
-              rin.to_s
-            else
-              rin
-            end
-          )
-          tmp.flush
-          command = "{ #{ command } ;} < #{ tmp.path }"
-          #puts command
-          super(command, redirects, &block)
-        ensure
-          tmp.close! if tmp 
-        end
-
-      else
-        super
-      end
-#--}}}
-    end
-#--}}}
-  end # class Sh
-  class Bash < Sh
-#--{{{
-    DEFAULT_PROG = 'bash'
-    class Login < Bash
-      DEFAULT_PROG = 'bash --login'
-    end
-#--}}}
-  end # class Bash
-  class Shell < Bash; end
-  # IDL => interactive data language - see http://www.rsinc.com/
-  class IDL < AbstractSession
-#--{{{
-    class LicenseManagerError < StandardError; end
-    DEFAULT_PROG = 'idl'
-    MAX_TRIES = 32 
-    def initialize(*args)
-#--{{{
-      tries = 0 
-      ret = nil
-      begin
-        ret = super
-      rescue LicenseManagerError => e
-        tries += 1 
-        if tries < MAX_TRIES
-          sleep 1
-          retry
-        else
-          raise LicenseManagerError, "<#{ MAX_TRIES }> attempts <#{ e.message }>"
-        end
-      end
-      ret
-#--}}}
-    end
-    def clear
-#--{{{
-      stdin.puts "retall"
-      stdin.puts "printf, -2, '__clear__'"
-      stdin.puts "printf, -1, '__clear__'"
-      stdin.flush
-      while((line = stderr.gets) and line !~ %r/__clear__/o)
-        raise LicenseManagerError, line if line =~ %r/license\s*manager/io
-      end
-      while((line = stdout.gets) and line !~ %r/__clear__/o)
-        raise LicenseManagerError, line if line =~ %r/license\s*manager/io
-      end
-      self
-#--}}}
-    end
-    def send_command cmd
-#--{{{
-      stdin.printf "printf, -2, '%s'\n", cmd.begin_err
-      stdin.printf "printf, -1, '%s'\n", cmd.begin_out
-
-      stdin.printf "%s\n", cmd.cmd
-      stdin.printf "retall\n"
-
-      stdin.printf "printf, -2, '%s'\n", cmd.end_err
-      stdin.printf "printf, -1, '%s'\n", cmd.end_out
-      stdin.flush
-#--}}}
-    end
-    def path 
-#--{{{
-      stdout, stderr = execute "print, !path"
-      stdout.strip.split %r/:/o
-#--}}}
-    end
-    def path= arg 
-#--{{{
-      case arg
-        when Array
-          arg = arg.join ':'
-        else
-          arg = arg.to_s.strip
-      end
-      stdout, stderr = execute "!path='#{ arg }'"
-
-      self.path
-#--}}}
-    end
-#--}}}
-  end # class IDL
-  module Spawn
-#--{{{
-    class << self
-      def spawn command
-#--{{{
-        ipath = tmpfifo
-        opath = tmpfifo
-        epath = tmpfifo
-
-        cmd = "#{ command } < #{ ipath } 1> #{ opath } 2> #{ epath } &"
-        system cmd 
-
-        i = open ipath, 'w'
-        o = open opath, 'r'
-        e = open epath, 'r'
-
-        [i,o,e]
-#--}}}
-      end
-      def tmpfifo
-#--{{{
-        path = nil
-        42.times do |i|
-          tpath = File::join(Dir::tmpdir, "#{ $$ }.#{ rand }.#{ i }")
-          v = $VERBOSE
-          begin
-            $VERBOSE = nil
-            system "mkfifo #{ tpath }"
-          ensure
-            $VERBOSE = v 
-          end
-          next unless $? == 0
-          path = tpath
-          at_exit{ File::unlink(path) rescue STDERR.puts("rm <#{ path }> failed") }
-          break
-        end
-        raise "could not generate tmpfifo" unless path
-        path
-#--}}}
-      end
-    end
-#--}}}
-  end # module Spawn
-#--}}}
-end # module Session