simplews 1.1.6 → 1.3.1

data/History.txt

@@ -1,3 +1,26 @@
+== 1.3.1 2008-12-20
+
+* 1 minor enhancement:
+  * Use Marshal instead of YAML, it seems faster...
+
+* 1 mayor enhancement:
+  * Removed old versions of job based servers
+
+== 1.3.0 2008-12-20
+
+* 1 minor enhancement:
+  * New version for asynchronous job. In this case it uses fork to spawn new
+    processes.
+
+
+
+== 1.1.7 2008-11-27
+
+* 2 minor enhancement:
+  * Inline methods are prepended '_inline_' to avoid polluting namespace
+  * Asynchronous jobs have a hash where they can save information, it is
+    accessible through the 'info' WS method in YAML format
+
 == 1.1.6 2008-11-24
 
 * 1 minor enhancement:

data/Manifest.txt

@@ -1,12 +1,12 @@
 History.txt
 Manifest.txt
 PostInstall.txt
-README.rdoc
+README.txt
 Rakefile
 config/hoe.rb
 config/requirements.rb
 lib/simplews.rb
-lib/simplews/asynchronous.rb
+lib/simplews/jobs.rb
 lib/simplews/version.rb
 script/console
 script/destroy
@@ -16,7 +16,7 @@ setup.rb
 tasks/deployment.rake
 tasks/environment.rake
 tasks/website.rake
-test/simplews/test_asynchronous.rb
+test/simplews/test_jobs.rb
 test/test_helper.rb
 test/test_simplews.rb
 website/index.html

data/lib/simplews/jobs.rb

@@ -0,0 +1,405 @@
+require File.join(File.dirname(File.dirname(__FILE__)) + '/simplews')
+
+require 'yaml'
+require 'drb'
+require 'singleton'
+require 'rand'
+
+
+class SimpleWS::Jobs < SimpleWS
+  class JobNotFound < Exception; end
+  class ResultNotFound < Exception; end
+  class Aborted < Exception; end
+
+
+  #{{{ Scheduler
+  
+  module Scheduler
+    include Process
+
+    @@task_results = {}
+    
+    @@names = []
+    @@pids = {}
+    
+    @@queue = []
+    @@max_jobs = 3
+    
+    def self.random_name(s="", num=20)
+      num.times{
+        r = rand
+        if r < 0.3
+          s << (rand * 10).to_i.to_s
+        elsif r < 0.6
+          s << (rand * (?z - ?a) + ?a).to_i.chr
+        else 
+          s << (rand * (?Z - ?A) + ?A).to_i.chr
+        end
+      }
+      s.to_s
+    end
+
+    def self.make_name(name = "")
+      name = Scheduler::random_name("job-") unless name =~ /\w/
+
+      taken = @@names.select{|n| n =~ /^#{ name }(-\d+)?$/}
+      if taken.any?
+        if taken.length == 1
+          return name + '-1'
+        else
+          last = taken.collect{|s| 
+            if s.match(/-(\d+)$/)
+              $1.to_i 
+            else 0 
+            end
+          }.sort.last
+          return name + '-' + (last + 1).to_s
+        end
+      else
+        return name
+      end
+    end
+
+    def self.configure(name, value)
+      Job::configure(name, value)
+    end
+
+    def self.helper(name, block)
+      Job.send :define_method, name, block
+    end
+
+    def self.task(name, results, block)
+      @@task_results[name] = results
+      Job.send :define_method, name, block
+    end
+
+    def self.dequeue
+      if @@pids.length < @@max_jobs && @@queue.any?
+        job_info = @@queue.pop
+
+        pid = Job.new.run(job_info[:task], job_info[:name], @@task_results[job_info[:task]], *job_info[:args])
+        @@pids[job_info[:name]] = pid
+        pid
+      else
+        nil
+      end
+    end
+
+    def self.run(task, *args)
+      suggested_name = *args.pop
+      name = make_name(suggested_name)
+      @@names << name
+
+      @@queue.push( {:name => name, :task => task, :args => args})
+      state = {
+          :name => name, 
+          :status => :queued, 
+          :messages => [], 
+          :info => {}, 
+      }
+      Job.save(name,state)
+ 
+      name
+    end
+
+    def self.clean_job(pid)
+      name = @@pids.select{|name, p| p == pid}.first[0]
+      puts "Process #{ name } with pid #{ pid } finished with exitstatus #{$?.exitstatus}"
+      state = Job.job_info(name)
+      if ![:error, :done, :aborted].include?(state[:status])
+        state[:status] = :error
+        state[:messages] << "Job finished for unknown reasons"
+        Job.save(name, state)
+      end
+      @@pids.delete(name)
+    end
+
+    def self.job_monitor
+      Thread.new{
+        while true
+          pid = dequeue
+          if pid
+            Thread.new(pid){|pid|
+              begin
+                pid = Process.wait(-1,Process::WUNTRACED) if @@pids.any?
+                clean_job(pid) if @@pids.values.include? pid
+              rescue Exception
+                puts $!.message
+              end
+            }
+          end
+          sleep 2
+        end
+      }
+    end
+
+    def self.abort(name)
+      Process.kill "INT", @@pids[name]
+    end
+
+    def self.abort_jobs
+      @@pids.values{|pid|
+        Process.kill "INT", pid
+      }
+    end
+
+    def self.job_info(name)
+      Job.job_info(name)
+    end
+
+    def self.workdir=(workdir)
+      Job.workdir = workdir
+    end
+
+    def self.job_results(name)
+      Job.results(name)   
+    end
+
+    #{{{ Job
+    
+    class Job
+      def self.workdir=(workdir)
+        @@workdir = workdir
+        @@savedir = File.join(@@workdir, '.save')
+        FileUtils.mkdir_p @@workdir unless File.exist? @@workdir
+        FileUtils.mkdir_p @@savedir unless File.exist? @@savedir
+      end
+
+      def self.path(file, name)
+        if file =~ /^\//
+          file.gsub(/\{JOB\}/)
+        else
+          File.join(@@workdir, file.gsub(/\{JOB\}/,name))
+        end
+      end
+
+      def self.save(name, state)
+        fout = File.open(File.join(@@savedir,name + '.marshal'),'w')
+        fout.write Marshal::dump(state)
+        fout.close
+      end
+
+      def self.job_info(name)
+        info = nil
+        begin
+          sleep 1
+          info = Marshal::load(File.open(File.join(@@savedir,name + '.marshal')))
+          raise Exception unless info.is_a? Hash
+        rescue Exception
+          raise JobNotFound, "Job with name #{ name } was not found"
+        end
+
+        info
+      end
+
+      def self.results(name)
+        job_info(name)[:results].collect{|file|
+          code = Scheduler.random_name("res-")
+          [code, file]
+        }
+      end
+
+      @@config = {}
+      def self.configure(name, value)
+        @@config[name] = value
+      end
+
+      def workdir
+        @@workdir
+      end
+
+      def config
+        @@config
+      end
+
+      def path(file)
+        Job.path(file,  @name)
+      end
+
+      def save
+        Job.save(@name, @state)
+      end
+
+      def write(file, contents)
+        path = Job.path(file, @name)
+        fout = File.open(path,'w')
+        fout.write contents
+        fout.close
+      end
+
+      def step(status, message = nil)
+        @state[:status] = status
+        @state[:messages] << message if message && message != ""
+        save
+      end
+      
+      def error(message = nil)
+        step(:error, message)
+        save
+      end
+
+      def info(info)
+        @state[:info].merge!(info)
+        save
+      end
+
+      def results(results)
+        @state[:results] = results.collect{|file| path(file)}
+        save
+      end
+
+      def abort
+        raise SimpleWS::Jobs::Aborted
+        save
+      end
+
+      def job_name
+        @name
+      end
+
+      def run(task, name, results, *args)
+        @name = name
+        @state = {
+          :name => @name, 
+          :status => :prepared, 
+          :messages => [], 
+          :info => {}, 
+          :results => results.collect{|file| path(file)},
+        }
+        save
+        @pid = Process.fork do
+          begin
+            trap(:INT) { raise SimpleWS::Jobs::Aborted }
+            self.send task, *args
+            step :done
+            exit(0)
+          rescue  SimpleWS::Jobs::Aborted
+            step(:aborted)
+            exit(-1)
+          rescue Exception
+            if !$!.kind_of? SystemExit
+              error($!.message)
+              puts "Error in job #{ @name }"
+              puts $!.message
+              puts $!.backtrace
+              exit(-1)
+            end
+          end
+        end
+
+        @pid
+      end
+    end
+  end
+
+  
+  def self.helper(name, &block)
+    Scheduler.helper name, block
+  end
+
+  def helper(name,&block)
+    Scheduler.helper name, block
+  end
+
+  def self.configure(name, value)
+    Scheduler.configure(name, value)
+  end
+
+  def configure(name, value)
+    self.class.configure(name, value)
+  end
+
+  def task(name, params=[], types={}, results = [], &block)
+    Scheduler.task name, results, block
+    serve name.to_s, params + ['suggested_name'], types.merge(:suggested_name => 'string', :return => :string) do |*args|
+      Scheduler.run name, *args
+    end
+  end
+
+  @@tasks = {}
+  def self.task(name, params=[], types={}, results =[], &block)
+    Scheduler.task name, results, block
+    @@tasks[name] = {:params => params, :types => types};
+  end
+
+  def abort_jobs
+    Scheduler.abort_jobs
+  end
+
+
+  def workdir
+    @workdir
+  end
+
+  def initialize(name, description, host, port, workdir = nil, *args)
+    super(name, description, host, port, *args)
+
+    @workdir = workdir || "/tmp/#{ name }"
+    Scheduler.workdir = @workdir
+    @results = {}
+    @@tasks.each{|task, values|
+      serve task.to_s, values[:params] + ['suggested_name'], values[:types].merge(:suggested_name => 'string', :return => :string) do |*args|
+        Scheduler.run task, *args
+      end
+    }
+
+    serve :status, ['job'], :job => :string, :return => :string do |job|
+      Scheduler.job_info(job)[:status].to_s
+    end
+
+    serve :messages, ['job'], :job => :string, :return => :array do |job|
+      Scheduler.job_info(job)[:messages]
+    end
+
+    serve :info, ['job'], :job => :string, :return => :string do |job|
+      Scheduler.job_info(job)[:info].to_yaml
+    end
+
+    serve :abort, %w(job), :job => :string do |job|
+      Scheduler.abort(job)
+    end
+
+    serve :done, %w(job), :job => :string, :return => :boolean do |job|
+      [:done, :error, :aborted].include? Scheduler.job_info(job)[:status]
+    end
+
+    serve :error, %w(job), :job => :string, :return => :boolean do |job|
+      Scheduler.job_info(job)[:status] == :error
+    end
+
+    serve :aborted, %w(job), :job => :string, :return => :boolean do |job|
+      Scheduler.job_info(job)[:status] == :aborted
+    end
+
+    serve :results, %w(job), :return => :array do |job|
+      results = Scheduler.job_results(job)    
+      @results.merge! Hash[*results.flatten]
+      results.collect{|p| p[0]}
+    end
+
+    serve :result, %w(result), :return => :binary do |result|
+      path = @results[result]
+      raise ResultNotFound unless File.exist? path
+      File.open(path).read
+    end
+
+  end
+
+  alias_method :old_start, :start
+  def start(*args)
+    Scheduler.job_monitor
+    old_start(*args)
+  end
+
+  alias_method :old_shutdown, :shutdown
+  def shutdown(*args)
+    Scheduler.abort_jobs
+    old_shutdown(*args)
+  end
+
+
+
+end
+
+
+

data/lib/simplews/version.rb

@@ -1,8 +1,8 @@
 module Simplews
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 1
-    TINY  = 6
+    MINOR = 3
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
     self

data/lib/simplews.rb

@@ -109,11 +109,14 @@ class SimpleWS <  SOAP::RPC::StandaloneServer
   def serve(name, args=[], types={}, &block)
     
     if block
-      add_to_ruby(name, &block)
+      inline_name = "_inline_" + name.to_s
+      add_to_ruby(inline_name, &block)
+      add_method_as(self,inline_name, name.to_s,*args)
+    else
+      add_method(self,name.to_s,*args)
     end
 
     add_to_wsdl(name, args, types)
-    add_method(self,name.to_s,*args)
 
     nil
   end

data/test/simplews/test_jobs.rb

@@ -0,0 +1,93 @@
+require File.dirname(File.dirname(__FILE__)) + '/test_helper.rb'
+
+
+class TestJobs < Test::Unit::TestCase
+  class TestJWS < SimpleWS::Jobs
+
+    task :process,[],{},['test.txt'] do
+      begin
+        info(:steps => 3)
+        write('test.txt', job_name)
+        step(:init)
+        sleep 2
+        step(:step1, "Step1")
+        sleep 2
+        step(:step2, "Step2")
+        sleep 2
+        step(:step3, "Step3")
+      rescue
+        error($!.message)
+      end
+    end
+  end
+
+
+  def setup
+    @server = TestJWS.new("TestJWS", "Asynchronous Job Server", 'localhost', '1984', "tmp-TestJWS")
+
+    Thread.new do
+      @server.start
+    end
+
+  end
+
+  def teardown
+    @server.shutdown
+  end
+
+  def test_client
+
+    require 'soap/wsdlDriver'
+
+    driver = SimpleWS.get_driver('http://localhost:1984', 'TestJWS')
+
+
+    name = driver.process("test")
+    puts "Job name #{ name }"
+
+    while !driver.done(name)
+      puts "status: " + driver.status(name)
+      sleep 1
+    end
+
+    assert_equal(3, YAML.load(driver.info(name))[:steps])
+    assert(!driver.error(name))
+    assert(driver.messages(name).include? "Step3")
+    assert(driver.results(name).length == 1)
+    result = driver.results(name).first
+    assert_match(name, driver.result(result))
+
+    name = driver.process("test-abort")
+    sleep 2
+    puts "status: " + driver.status(name)
+    driver.abort(name)
+    sleep 2
+    puts driver.status(name)
+    puts driver.messages(name)
+    assert(driver.aborted(name))
+
+    FileUtils.cp "tmp-TestJWS/.save/test-abort.yaml", "tmp-TestJWS/.save/copy.yaml"
+    assert(driver.aborted("copy"))
+    
+    # Test queue
+    threads = []
+    10.times {
+      threads << Thread.new{
+        test_name = driver.process("test-queue")
+        puts "Starting #{ test_name }"
+        while !driver.done(test_name)
+          puts "#{ test_name }: " + driver.status(test_name)
+          sleep 2
+        end
+      }
+      sleep 2
+    }
+
+    puts "Threads " +  threads.length.to_s
+    threads.each{|t| t.join}
+    sleep 10
+
+
+  end
+
+end

data/test/test_helper.rb

@@ -1,3 +1,5 @@
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/simplews'
 require File.dirname(__FILE__) + '/../lib/simplews/asynchronous'
+require File.dirname(__FILE__) + '/../lib/simplews/forked'
+require File.dirname(__FILE__) + '/../lib/simplews/jobs'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simplews
 version: !ruby/object:Gem::Version 
-  version: 1.1.6
+  version: 1.3.1
 platform: ruby
 authors: 
 - Miguel Vazquez
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-24 00:00:00 +01:00
+date: 2009-01-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: 1.8.0
     version: 
 description: Simplifies the development of Web Services, producing WSDL automatically for example. Wraps soap4r.
 email: 
@@ -33,17 +33,18 @@ extra_rdoc_files:
 - History.txt
 - Manifest.txt
 - PostInstall.txt
+- README.txt
 - website/index.txt
 files: 
 - History.txt
 - Manifest.txt
 - PostInstall.txt
-- README.rdoc
+- README.txt
 - Rakefile
 - config/hoe.rb
 - config/requirements.rb
 - lib/simplews.rb
-- lib/simplews/asynchronous.rb
+- lib/simplews/jobs.rb
 - lib/simplews/version.rb
 - script/console
 - script/destroy
@@ -53,7 +54,7 @@ files:
 - tasks/deployment.rake
 - tasks/environment.rake
 - tasks/website.rake
-- test/simplews/test_asynchronous.rb
+- test/simplews/test_jobs.rb
 - test/test_helper.rb
 - test/test_simplews.rb
 - website/index.html
@@ -91,11 +92,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: simplews
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Simplifies the development of Web Services, producing WSDL automatically for example. Wraps soap4r.
 test_files: 
 - test/test_simplews.rb
 - test/test_helper.rb
-- test/simplews/test_asynchronous.rb
+- test/simplews/test_jobs.rb

data/lib/simplews/asynchronous.rb

@@ -1,502 +0,0 @@
-require File.join(File.dirname(File.dirname(__FILE__)) + '/simplews')
-
-require 'yaml'
-
-# This class extends SimpleWS and allows provides with a framework to
-# run asynchronous jobs. Job are initiated and can be latter be accessed
-# using a unique job id. The status can be queried, and when finished,
-# the results can be gathered. Jobs are also able to save their states
-# between executions of the server.
-#
-# The class provides a instance function start_job, that receives a
-# block of code and creates a new thread to run this block of code. It
-# also provides some helper functions to set the state of the job, as
-# well as messages or to abort of report errors. 
-#
-# Each job can produce a number of results saved into files that can
-# latter be accessed by the client. At any time the code inside the
-# block can access any of the following helper functions: step, read,
-# write, abort_process, job_name and save. As in the following example.
-# (+process+ will be a method served by the server):
-#
-#   def process(name)
-#      start_job(name, %w(test.txt)) do
-#        begin
-#          write('test.txt', job_name)
-#          step(:init)
-#          sleep 2
-#          step(:step1, "Step1")
-#          sleep 2
-#          step(:step2, "Step2")
-#          sleep 2
-#          step(:step2, "Step3")
-#        rescue
-#          error($!.message)
-#        end
-#      end
-#   end
-#
-# Note that any file specified in the write or read method is relative
-# to the workdir directory. The optional array passed as second argument
-# to start_job lists the results the job will be generating and that
-# will be accessible latter to the clients, one could  have also done
-# this:
-#
-#   def process(name)
-#      actual_name = start_job(name) do
-#        begin
-#          write(job_name + ".txt", "Hi")
-#          step(:init)
-#          sleep 2
-#          step(:step1, "Step1")
-#          sleep 2
-#          step(:step2, "Step2")
-#          sleep 2
-#          step(:step2, "Step3")
-#        rescue
-#          error($!.message)
-#        end
-#      end
-#      
-#      set_results(actual_name, [ actual_name + ".txt" ])
-#      
-#      actual_name
-#   end
-#
-# Note in this example that the name provided to start_job is only a
-# suggestion, it a job is already available with that name a number will
-# be prepended to it. The actual name used is return by the start_job
-# method and is the one that must be used in the set_results method.
-# Also note that the +process+ method in the example has to return the
-# actual name of the job so it will be accessible to the client.
-#
-#
-# The clients have a number of methods available to query and modify the
-# state of the job, as well as to gather results: status, messages,
-# done, error, aborted, abort, results and result.
-# 
-#
-# While reading the documentation please note that there are three types
-# of methods here, methods used inside the web server methods, methods
-# used inside code blocks executed by Job Threads, and methods that are
-# exported by the web server. Its important to call each method in the
-# right context.
-#
-class SimpleWS::Asynchronous < SimpleWS
-
-  
-  class JobNotFound < Exception; end
-  class JobAborted < Exception; end
-
-  
-  class Job < Thread # :nodoc:
-
-    private
-
-    def self.random_name(s="", num=20)
-      num.times{
-        r = rand
-        if r < 0.3
-          s << (rand * 10).to_i.to_s
-        elsif r < 0.6
-          s << (rand * (?z - ?a) + ?a).to_i.chr
-        else 
-          s << (rand * (?Z - ?A) + ?A).to_i.chr
-        end
-      }
-      s.to_s
-    end
-
-    def self.make_name(name)
-
-      name = Job::random_name("job-") if name == ""
-
-      taken = @@jobs.keys.select{|n| n =~ /^#{ name }(-\d+)?$/}
-      if taken.any?
-        last = taken.sort.last
-        if last == name
-          return name + '-1'
-        else
-          num = last.match(/-(\d+)$/)[1]
-          return name + '-' + (num.to_i + 1).to_s
-        end
-      else
-        return name
-      end
-    end
-
-    public
-
-    # Returns the job specified in the +name+. If it is not currently
-    # found but it has a saved state, then it is loaded.
-    def self.job(name)
-      if @@jobs[name].nil?
-        if File.exists?(File.join(@@workdir, ".save/#{name}.yaml"))
-          job = Job.new(name, [])
-          job.load
-          @@jobs[name] = job
-        else
-          raise SimpleWS::Asynchronous::JobNotFound, "Job with name '#{ name }' was not found" 
-        end
-      end
-      @@jobs[name]
-    end
-
-    def self.start(name, results, &block)
-      job = Job.new(name, results, &block)
-      @@jobs[job.name] = job
-      job.name
-    end
-
-    def self.read(name, path)
-      Job::job(name).read(path)
-    end
-
-
-    @@workdir = nil
-    @@jobs = {}
-
-    def self.workdir
-      @@workdir
-    end
-
-    def self.workdir=(workdir)
-      @@workdir = workdir
-      begin
-        FileUtils.mkdir_p(@@workdir) unless File.exist?( @@workdir)
-        FileUtils.mkdir(File.join(@@workdir,'.save')) unless File.exist?( File.join(@@workdir,'.save'))
-      rescue
-        puts "Error creating work directory:"
-        raise $!
-      end
-    end
-
-    attr_reader :messages, :status, :name
-    def initialize(name, results, &block)
-      @status = ''
-      @messages = []
-      @name = Job::make_name(name)
-      @results = results
-      @results_hash = {}
-
-      if block_given?
-        super do
-          begin
-            block.call
-            step(:done)
-
-          rescue SimpleWS::Asynchronous::JobAborted
-            step(:aborted, $!.message)
-          rescue Exception
-            error($!.message)
-            raise $!
-          ensure
-            save
-            Thread.exit
-          end
-        end
-      else
-        super do end
-      end
-    end
-
-    def save
-      info = {
-        :status => @status,
-        :messages => @messages,
-        :name => @name,
-        :results => @results,
-        :results_hash => @results_hash,
-      }
-
-      fout = File.open(File.join(@@workdir, ".save/#{name}.yaml"),'w')
-      fout.write info.to_yaml
-      fout.close
-    end
-
-    def load
-      info = YAML::load(File.open(File.join(@@workdir, ".save/#{@name}.yaml")))
-      @status = info[:status]
-      @messages = info[:messages]
-      @name = info[:name]
-      @results = info[:results]
-      @results_hash = info[:results_hash]
-    end
-
-    #{{{ Instance methods
-    def name
-      @name
-    end
-
-    def step(status, message= nil)
-      @status = status
-      @messages << message if message && message != ""
-    end
-
-    def read(path)
-      File.open(File.join(@@workdir, path)).read
-    end
-
-    def write(path, content)
-      f = File.open(File.join(@@workdir, path),'w')
-      f.write(content)
-      f.close
-    end
-
-    #{{{ Results Related
-    def results=(list)
-      @results = list
-    end
-
-    def results
-      @results.collect{|res|
-        res_name = Job.random_name("result-")
-        @results_hash[res_name] = res
-        res_name
-      }
-    end
-
-    def result(res_name)
-      raise ArgumentError, "Result #{ res_name } not found" if @results_hash[res_name].nil?
-      File.open(File.join(@@workdir, @results_hash[res_name])).read
-    end
-
-    #{{{ Status related
-    def status
-      @status.to_s
-    end
-
-    def done?
-      @status.to_sym == :done || @status.to_sym == :error || @status.to_sym == :aborted
-    end
-
-    def error?
-      @status.to_sym == :error
-    end
-
-    def error(message)
-      step(:error, message)
-    end
-
-    def abort
-      raise SimpleWS::Asynchronous::JobAborted, "Aborted"
-      nil
-    end
-
-    def aborted?
-      @status.to_sym == :aborted
-    end
-
-
-  end
-
-  ############################################################################################3
-  #{{{ Server
-
-  # SERVER METHOD:
-  #
-  # Sets the workdir for the jobs
-  def set_workdir(workdir)
-    Job::workdir = workdir
-  end
-  
-  # SERVER METHOD:
-  #
-  # Returns the workdir that any jobs created will be using
-  def workdir
-    Job::workdir
-  end
-  
-  # SERVER METHOD:
-  #
-  # Starts a new job. The parameter +name+ is just a suggestion, if it
-  # is not available a number will be prepended to it. Results are a
-  # list of relative paths to files where results are expected to be
-  # stored. All paths are relative to the jobs workdir. Finally, block
-  # is the block of code to be executed by the Job Thread.
-  #
-  # Returns the actual name used as unique identifier for the job
-  def start_job(name, results = [], &block)
-    Job.start(name, results, &block)
-  end
-
-  # SERVER METHOD:
-  #
-  # Sets the list of paths to results for a particular job. This
-  # overwrites the ones specified by start_job.
-  def set_results(name, results)
-    Job.job(name).results = results
-  end
-
-
-
-  #{{{ Thread helper methods
-  
-
-  # CODE HELPER FUNCTION:
-  #
-  # Saves the job to it can survive server restarts. This is
-  # automatically called when the code is finished.
-  def save
-    Thread.current.save
-  end
-
-  # CODE HELPER FUNCTION:
-  #
-  # Writes +content+ into the file specified by +path+. The +path+`is
-  # taken relative to the job's workdir.
-  def write(path, content)
-    Thread.current.write(path, content)
-  end
-
-  # CODE HELPER FUNCTION:
-  #
-  # Reads the content of the file specified by +path+ relative to the
-  # job's workdir. 
-  def read(path)
-    Thread.current.read(path)
-  end
-
-
-  # CODE HELPER FUNCTION:
-  #
-  # Sets the status of the job and adds a message to the message queue
-  # if the message is specified, and is different from an empty string.
-  # This method is called automatically in the following situations.
-  #
-  # * The block has finished executing:
-  #      step(:done)
-  # * The job recieves an untreated SimpleWS::Asynchronous::JobAborted  exception
-  #      step(:aborted, $!.message)
-  # * The job recieves any other exception
-  #      step(:error, $!.message)
-  #
-  def step(status, message=nil)
-    Thread.current.step(status, message)
-  end
-
-
-  # CODE HELPER FUNCTION:
-  #
-  # Returns the actual name of the job running the code.
-  def job_name
-    Thread.current.name
-  end
-
-  # CODE HELPER FUNCTION:
-  #
-  # Aborts the job raising a SimpleWS::Asynchronous::JobAborted
-  # exception.
-  def abort_process
-    Thread.current.abort
-  end
-
-
-  #{{{ WS Methods
-
-  # CLIENT METHOD SERVED BY DEFAULT: 
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Returns job status of the job.
-  def status(name)
-    Job.job(name).status
-  end
-
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Raises a SimpleWS::Asynchronous::JobAborted exception in the job
-  def abort(name)
-    Job.job(name).abort
-  end
-
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Checks if the job is still running or has finished, either normally
-  # or after been aborted or suffering an error.
-  def done(name)
-    Job.job(name).done?
-  end
- 
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Checks if the job has been aborted.
-  def aborted(name)
-    Job.job(name).aborted?
-  end
- 
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Checks if the job has suffered an error
-  def error(name)
-    Job.job(name).error?
-  end
- 
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Returns the list of messages of the job.
-  def messages(name)
-    Job.job(name).messages
-  end
- 
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  #
-  # Returns a list of unique results identifiers, one for each of the
-  # results of the job.
-  def results(name)
-    Job.job(name).results
-  end
- 
-  # CLIENT METHOD SERVED BY DEFAULT:
-  #
-  # +name+ is the unique job identifier.
-  # +result+ is the unique result identifier as returned by the results
-  # method.
-  #
-  # Retrieves a result of a given job.
-  def result(name, result)
-    Job.job(name).result(result)
-  end
-
-
-  # Creates an instance. All the parameters are as in SimpleWS, except
-  # for the additional workdir parameter. It the workdir is not provided
-  # a directory in the /tmp directory with the name of the server will
-  # be used.
-  #
-  # It serves by default the methods: abort, messages, status, done,
-  # error, abort, aborted, results and result, as well as the +wsdl+
-  # method from SimpleWS.
-  def initialize(name="WS", description="", host="localhost", port="1984", workdir=nil, *args)
-    super(name, description, host, port, *args)
-    @results = {}
-
-    workdir ||= "/tmp/#{ name }"
-    set_workdir(workdir)
-
-    serve :abort, %w(name), :name => :string
-
-    serve :messages, %w(name), :name => :string, :return => :string
-
-    serve :status, %w(name), :name => :string, :return => :string
-    serve :done, %w(name), :name => :string, :return => :boolean
-    serve :error, %w(name), :name => :string, :return => :boolean
-    serve :aborted, %w(name), :name => :string, :return => :boolean
-
-    serve :results, %w(name), :return => :array
-    serve :result, %w(name result), :return => :binary
-  end
-
-end

data/test/simplews/test_asynchronous.rb

@@ -1,88 +0,0 @@
-require File.dirname(File.dirname(__FILE__)) + '/test_helper.rb'
-
-class TestSimpleWS < Test::Unit::TestCase
-
-  class TestAWS < SimpleWS::Asynchronous
-
-    def text
-      "Hi"
-    end
-
-    def process(name)
-      actual_name = start_job(name, %w(test.txt)) do
-        begin
-          write('test.txt', job_name)
-          step(:init)
-          sleep 2
-          step(:step1, "Step1")
-          sleep 2
-          step(:step2, "Step2")
-          sleep 2
-          step(:step2, "Step3")
-        rescue
-          error($!.message)
-        end
-      end
-
-      actual_name
-    end
-
-    def initialize(*args)
-      super(*args)
-      serve :process, %w(name), :name => :string, :return => :string
-    end
-  end
-
-
-  def setup
-    server = TestAWS.new("TestAWS", "Asynchronous Job Server", 'localhost', '1984')
-    server.set_workdir("tmp-TestAWS")
-
-    Thread.new do
-      server.start
-    end
-
-  end
-
-  def test_client
-
-    require 'soap/wsdlDriver'
-
-    driver = SimpleWS.get_driver('http://localhost:1984', 'TestAWS')
-
-    name = driver.process("")
-    
-   
-
-    puts "Job name #{ name }"
-
-    while !driver.done(name)
-      puts "status: " + driver.status(name)
-      sleep 1
-    end
-
-    assert(!driver.error(name))
-    assert(driver.messages(name).include? "Step3")
-    assert(driver.results(name).length == 1)
-
-    result = driver.results(name).first
-    assert_match(name, driver.result(name, result))
-
-
-    name = driver.process("test-AWS")
-    sleep 2
-    puts "status: " + driver.status(name)
-    driver.abort(name)
-    sleep 2
-    puts driver.status(name)
-    assert(driver.aborted(name))
-
-    FileUtils.cp "tmp-TestAWS/.save/test-AWS.yaml", "tmp-TestAWS/.save/copy-AWS.yaml"
-    assert(driver.aborted("copy-AWS"))
-
-    
-  end
-
-
-
-end