opentox-ruby-api-wrapper 1.4.0 → 1.5.0

data/lib/rest_client_wrapper.rb

@@ -0,0 +1,170 @@
+
+
+module OpenTox
+
+  #PENDING: implement ot error api, move to own file
+  class Error
+    
+    attr_accessor :code, :body, :uri, :payload, :headers
+    
+    def initialize(code, body, uri, payload, headers)
+      self.code = code
+      self.body = body
+      self.uri = uri
+      self.payload = payload
+      self.headers = headers
+    end
+    
+    def self.parse(error_array_string)
+      begin
+        err = YAML.load(error_array_string)
+        if err and err.is_a?(Array) and err.size>0 and err[0].is_a?(Error)
+          return err
+        else
+          return nil
+        end
+      rescue
+        return nil
+      end
+    end
+    
+  end
+  
+  class WrapperResult < String
+    attr_accessor :content_type, :code
+  end
+  
+  class RestClientWrapper
+    
+    def self.get(uri, headers=nil, wait=true)
+      execute( "get", uri, headers, nil, wait)
+    end
+    
+    def self.post(uri, headers, payload=nil, wait=true)
+      execute( "post", uri, headers, payload, wait )
+    end
+    
+    def self.put(uri, headers, payload=nil )
+      execute( "put", uri, headers, payload )
+    end
+
+    def self.delete(uri, headers=nil)
+      execute( "delete", uri, headers, nil)
+    end
+
+    def self.raise_uri_error(error_msg, uri, headers=nil, payload=nil)
+      do_halt( "-", error_msg, uri, headers, payload )         
+    end
+    
+    private
+    def self.execute( rest_call, uri, headers, payload=nil, wait=true )
+      
+      do_halt 400,"uri is null",uri,headers,payload unless uri
+      do_halt 400,"not a uri",uri,headers,payload unless Utils.is_uri?(uri)
+      do_halt 400,"headers are no hash",uri,headers,payload unless headers==nil or headers.is_a?(Hash)
+      do_halt 400,"nil headers for post not allowed, use {}",uri,headers,payload if rest_call=="post" and headers==nil
+      headers.each{ |k,v| headers.delete(k) if v==nil } if headers #remove keys with empty values, as this can cause problems
+      
+      begin
+        #LOGGER.debug "RestCall: "+rest_call.to_s+" "+uri.to_s+" "+headers.inspect
+        resource = RestClient::Resource.new(uri,{:timeout => 60}) #, :user => @@users[:users].keys[0], :password => @@users[:users].values[0]})
+        if payload
+          result = resource.send(rest_call, payload, headers)
+        elsif headers
+          result = resource.send(rest_call, headers)
+        else
+          result = resource.send(rest_call)
+        end
+        
+        # result is a string, with the additional fields content_type and code
+        res = WrapperResult.new(result.body)
+        res.content_type = result.headers[:content_type]
+        raise "content-type not set" unless res.content_type
+        res.code = result.code
+        
+        return res if res.code==200 || !wait
+        
+        while (res.code==201 || res.code==202)
+          res = wait_for_task(res, uri)
+        end
+        raise "illegal status code: '"+res.code.to_s+"'" unless res.code==200
+        return res
+        
+      rescue RestClient::RequestFailed => ex
+        do_halt ex.http_code,ex.http_body,uri,headers,payload
+      rescue RestClient::RequestTimeout => ex
+        do_halt 408,ex.message,uri,headers,payload
+      rescue => ex
+        #raise ex
+        #raise "'"+ex.message+"' uri: "+uri.to_s
+        begin
+          code = ex.http_code
+          msg = ex.http_body
+        rescue
+          code = 500
+          msg = ex.to_s
+        end
+        do_halt code,msg,uri,headers,payload
+      end
+    end
+    
+    def self.wait_for_task( res, base_uri )
+                          
+      task = nil
+      case res.content_type
+      when /application\/rdf\+xml|text\/x-yaml/
+        task = OpenTox::Task.from_data(res, res.content_type, res.code, base_uri)
+      when /text\//
+        raise "uri list has more than one entry, should be a task" if res.content_type=~/text\/uri-list/ and
+          res.split("\n").size > 1 #if uri list contains more then one uri, its not a task
+        task = OpenTox::Task.find(res.to_s) if Utils.task_uri?(res)
+      else
+        raise "unknown content-type for task: '"+res.content_type.to_s+"'" #+"' content: "+res[0..200].to_s
+      end
+      
+      LOGGER.debug "result is a task '"+task.uri.to_s+"', wait for completion"
+      task.wait_for_completion
+      raise task.description unless task.completed? # maybe task was cancelled / error
+      
+      res = WrapperResult.new task.resultURI
+      res.code = task.http_code
+      res.content_type = "text/uri-list"
+      return res
+    end
+    
+    def self.do_halt( code, body, uri, headers, payload=nil )
+      
+      #build error
+      causing_errors = Error.parse(body)
+      if causing_errors
+        error = causing_errors + [Error.new(code, "subsequent error", uri, payload, headers)]
+      else
+        error = [Error.new(code, body, uri, payload, headers)]
+      end
+
+#      #debug utility: write error to file       
+#      error_dir = "/tmp/ot_errors"
+#      FileUtils.mkdir(error_dir) unless File.exist?(error_dir)
+#      raise "could not create error dir" unless File.exist?(error_dir) and File.directory?(error_dir)
+#      file_name = "error"
+#      time=Time.now.strftime("%m.%d.%Y-%H:%M:%S")
+#      count = 1
+#      count+=1 while File.exist?(File.join(error_dir,file_name+"_"+time+"_"+count.to_s))
+#      File.new(File.join(error_dir,file_name+"_"+time+"_"+count.to_s),"w").puts(body)
+      
+      # handle error
+      # we are either in a task, or in sinatra
+      # PENDING: always return yaml for now
+      
+      if $self_task #this global var in Task.as_task to mark that the current process is running in a task
+        raise error.to_yaml # the error is caught, logged, and task state is set to error in Task.as_task
+      #elsif $sinatra  #else halt sinatra
+         #$sinatra.halt(502,error.to_yaml)
+      elsif defined?(halt)         
+         halt(502,error.to_yaml)
+      else #for testing purposes (if classes used directly)
+        raise error.to_yaml
+      end
+    end
+  end
+end

data/lib/spork.rb

@@ -37,6 +37,7 @@ module Spork
   def self.spork(options={})
     logger = options[:logger]
     logger.debug "spork> parent PID = #{Process.pid}" if logger
+    
     child = fork do
       begin
         start = Time.now
@@ -52,6 +53,7 @@ module Spork
         yield
 
       rescue => ex
+        #raise ex
         logger.error "spork> Exception in child[#{Process.pid}] - #{ex.class}: #{ex.message}" if logger
       ensure
         logger.info "spork> child[#{Process.pid}] took #{Time.now - start} sec" if logger

data/lib/task.rb

@@ -1,97 +1,170 @@
 LOGGER.progname = File.expand_path(__FILE__)
 
+$self_task=nil
+
 module OpenTox
 
 	class Task
 
-		attr_accessor :uri
-
-		def initialize(uri)
-			@uri = uri.chomp
-		end
-
-		def self.create
-      resource = RestClient::Resource.new(@@config[:services]["opentox-task"], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			uri = resource.post({}).chomp
-			Task.new(uri.chomp)
-		end
-
+    # due_to_time is only set in local tasks 
+    TASK_ATTRIBS = [ :uri, :date, :title, :creator, :description, :hasStatus, :percentageCompleted, :resultURI, :due_to_time ]
+    TASK_ATTRIBS.each{ |a| attr_accessor(a) }
+    attr_accessor :http_code
+    
+    private
+    def initialize(uri)
+      @uri = uri.to_s.strip
+    end
+    
+    # create is private now, use OpenTox::Task.as_task
+		def self.create(max_duration)
+      task_uri = RestClientWrapper.post(@@config[:services]["opentox-task"], {:max_duration => max_duration}, nil, false).to_s
+			Task.find(task_uri.chomp)
+		end
+
+    public
 		def self.find(uri)
-			Task.new(uri)
-		end
-
-		def self.base_uri
-			@@config[:services]["opentox-task"]
-		end
-
-		def self.all
-			task_uris = RestClient.get(@@config[:services]["opentox-task"]).chomp.split(/\n/)
-			task_uris.collect{|uri| Task.new(uri)}
-		end
-
-		def created_at
-			RestClient.get File.join(@uri, 'created_at')
-		end
-		 
-		def finished_at
-			RestClient.get File.join(@uri, 'finished_at')
-		end
-		 
-		def status
-			RestClient.get File.join(@uri, 'status')
-		end
-		 
-		def resource
-			RestClient.get File.join(@uri, 'resource')
-		end
-		 
-		def started
-      LOGGER.info File.join(@uri,'started')
-      resource = RestClient::Resource.new(File.join(@uri,'started'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-      resource.put({}) 
-		end
-
+      task = Task.new(uri)
+      task.reload
+      return task
+    end
+    
+    def self.from_data(data, content_type, code, base_uri)
+      task = Task.new(nil)
+      task.http_code = code
+      task.reload_from_data(data, content_type, base_uri)
+      return task
+    end
+    
+    def reload
+      result = RestClientWrapper.get(uri, {:accept => 'application/rdf+xml'}, false)#'application/x-yaml'})
+      @http_code = result.code
+      reload_from_data(result, result.content_type, uri)
+    end
+    
+    def reload_from_data( data, content_type, base_uri )
+      case content_type
+      when /yaml/
+        task =  YAML.load data
+        TASK_ATTRIBS.each do |a|
+          raise "task yaml data invalid, key missing: "+a.to_s unless task.has_key?(a)
+          send("#{a.to_s}=".to_sym,task[a])
+        end
+      when /application\/rdf\+xml/
+        owl = OpenTox::Owl.from_data(data,base_uri,"Task")
+        self.uri = owl.uri
+        (TASK_ATTRIBS-[:uri]).each{|a| self.send("#{a.to_s}=".to_sym, owl.get(a.to_s))}
+      else
+        raise "content type for tasks not supported: "+content_type.to_s
+      end
+      raise "uri is null after loading" unless @uri and @uri.to_s.strip.size>0
+    end
+    
 		def cancel
-			resource = RestClient::Resource.new(File.join(@uri,'cancelled'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			resource.put({})
+      RestClientWrapper.put(File.join(@uri,'Cancelled'))
+      reload
 		end
 
 		def completed(uri)
-			resource = RestClient::Resource.new(File.join(@uri,'completed'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			resource.put :resource => uri
+			RestClientWrapper.put(File.join(@uri,'Completed'),{:resultURI => uri})
+      reload
 		end
 
-		def failed
-			resource = RestClient::Resource.new(File.join(@uri,'failed'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			resource.put({})
+		def error(description)
+			RestClientWrapper.put(File.join(@uri,'Error'),{:description => description})
+      reload
 		end
+    
+    def pid=(pid)
+      RestClientWrapper.put(File.join(@uri,'pid'), {:pid => pid})
+    end
 
-		def parent=(task)
-			#RestClient.put File.join(@uri,'parent'), {:uri => task.uri}
-			resource = RestClient::Resource.new(File.join(@uri,'parent'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			LOGGER.debug "task.rb: #{resource}"
-			resource.put :uri => task.uri
-		end
-		 
-		def pid=(pid)
-		  resource = RestClient::Resource.new(File.join(@uri,'pid'), :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			resource.put :pid => pid
-		end
+    def running?
+      @hasStatus.to_s == 'Running'
+    end
 
 		def completed?
-			self.status.to_s == 'completed'
-		end
-
-		def failed?
-			self.status.to_s == 'failed'
-		end
-
-		def wait_for_completion(dur=0.1)
-			until self.completed? or self.failed?
+			@hasStatus.to_s == 'Completed'
+		end
+
+		def error?
+			@hasStatus.to_s == 'Error'
+		end
+
+    # waits for a task, unless time exceeds or state is no longer running
+		def wait_for_completion(dur=0.3)
+      
+      if (@uri.match(@@config[:services]["opentox-task"]))
+        due_to_time = Time.parse(@due_to_time)
+        running_time = due_to_time - Time.parse(@date)
+      else
+        # the date of the external task cannot be trusted, offest to local time might be to big
+        due_to_time = Time.new + EXTERNAL_TASK_MAX_DURATION
+        running_time = EXTERNAL_TASK_MAX_DURATION
+      end
+      LOGGER.debug "start waiting for task "+@uri.to_s+" at: "+Time.new.to_s+", waiting at least until "+due_to_time.to_s
+      
+			while self.running?
 				sleep dur
+        reload
+        check_state
+        if (Time.new > due_to_time)
+          raise "max wait time exceeded ("+running_time.to_s+"sec), task: '"+@uri.to_s+"'"
+        end
 			end
-		end
-
+      
+      LOGGER.debug "task no longer running: "+@uri.to_s+", result: "+@resultURI.to_s
+	  end
+  
+    def check_state
+      begin
+        raise "illegal task state, task is completed, resultURI is no URI: '"+@resultURI.to_s+
+            "'" unless @resultURI and Utils.is_uri?(@resultURI) if completed?
+        
+        if @http_code == 202
+          raise "illegal task state, code is 202, but hasStatus is not Running: '"+@hasStatus+"'" unless running?
+        elsif @http_code == 201
+          raise "illegal task state, code is 201, but hasStatus is not Completed: '"+@hasStatus+"'" unless completed?
+          raise "illegal task state, code is 201, resultURI is no task-URI: '"+@resultURI.to_s+
+              "'" unless @resultURI and Utils.task_uri?(@resultURI)
+        end
+      rescue => ex
+        RestClientWrapper.raise_uri_error(ex.message, @uri)
+      end
+    end
+  
+    # returns the task uri
+    # catches halts and exceptions, task state is set to error then
+    def self.as_task(max_duration=DEFAULT_TASK_MAX_DURATION)
+      #return yield nil
+      
+      task = OpenTox::Task.create(max_duration)
+      task_pid = Spork.spork(:logger => LOGGER) do
+        LOGGER.debug "Task #{task.uri} started #{Time.now}"
+        $self_task = task
+        
+        begin
+          result = catch(:halt) do
+            yield task
+          end
+          # catching halt, set task state to error
+          if result && result.is_a?(Array) && result.size==2 && result[0]>202
+            LOGGER.error "task was halted: "+result.inspect
+            task.error(result[1])
+            return
+          end
+          LOGGER.debug "Task #{task.uri} done #{Time.now} -> "+result.to_s
+          task.completed(result)
+        rescue => ex
+          LOGGER.error "task failed: "+ex.message
+          LOGGER.error ": "+ex.backtrace.join("\n")
+          task.error(ex.message)
+        end
+      end  
+      task.pid = task_pid
+      LOGGER.debug "Started task: "+task.uri.to_s
+      task.uri
+    end  
 	end
 
 end

data/lib/templates/config.yaml

@@ -1,13 +1,25 @@
 # Example configuration for OpenTox, please adjust to your settings
 # 
+# Database setup:
+#
+# Example MySql:
+#
+# :database: 
+#   :adapter:  mysql
+#   :database: production
+#   :username: production
+#   :password: your_password
+#   :host:     localhost
+#
 # Example 1: Using external test services
 #
 # :services:
-#  opentox-compound:      "http://webservices.in-silico.ch/test/compound/"
-#  opentox-dataset:       "http://webservices.in-silico.ch/test/dataset/"
-#  opentox-algorithm:     "http://webservices.in-silico.ch/test/algorithm/"
-#  opentox-model:         "http://webservices.in-silico.ch/test/model/"
-#  opentox-task:         "http://webservices.in-silico.ch/test/task/"
+#  opentox-compound:      "http://webservices.in-silico.ch/compound/"
+#  opentox-dataset:       "http://webservices.in-silico.ch/dataset/"
+#  opentox-algorithm:     "http://webservices.in-silico.ch/algorithm/"
+#  opentox-model:         "http://webservices.in-silico.ch/model/"
+#  opentox-task:          "http://webservices.in-silico.ch/task/"
+#  opentox-validation:    "http://opentox.informatik.uni-freiburg.de/validation/"
 #
 # Example 2: Using local services
 # :base_dir: /home/ch/webservices
@@ -18,3 +30,39 @@
 #   opentox-algorithm:     "http://localhost:4002/"
 #   opentox-model:         "http://localhost:4003/"
 #   opentox-task:          "http://localhost:4004/"
+#   opentox-validation:    "http://opentox.informatik.uni-freiburg.de/validation/"
+#
+# Accept headers:
+#
+# :accept_headers:
+#   opentox-compound:      
+#     - "chemical/x-daylight-smiles"
+#     - "chemical/x-inchi"
+#     - "chemical/x-mdl-sdfile"
+#     - "image/gif"
+#     - "text/plain"
+#   opentox-dataset:       
+#     - "application/x-yaml"
+#     - "text/x-yaml"
+#     - "application/rdf+xml"
+#   opentox-algorithm:     
+#     - "application/x-yaml"
+#     - "text/x-yaml"
+#     - "application/rdf+xml"
+#   opentox-model:         
+#     - "application/x-yaml"
+#     - "text/x-yaml"
+#     - "application/rdf+xml"
+#   opentox-task:          
+#     - "application/x-yaml"
+#     - "text/x-yaml"
+#     - "application/rdf+xml"
+#   opentox-validation:    
+#     - "application/x-yaml"
+#     - "text/x-yaml"
+#     - "application/rdf+xml"
+
+# Timeouts:
+# 
+# :default_task_max_duration: 3600
+# :external_task_max_duration: 3600

data/lib/utils.rb

@@ -4,6 +4,38 @@ module OpenTox
 		def self.gauss(sim, sigma = 0.3) 
 			x = 1.0 - sim
 			Math.exp(-(x*x)/(2*sigma*sigma))
-		end
-	end
+	  end
+    
+    def self.task_uri?(uri)
+      is_uri?(uri) && uri.to_s =~ /task/
+    end
+    
+    def self.dataset_uri?(uri)
+     is_uri?(uri) && uri.to_s =~ /dataset/
+    end
+   
+    def self.model_uri?(uri)
+     is_uri?(uri) && uri.to_s =~ /model/
+    end
+
+  
+    def self.is_uri?(uri)
+      return false if uri==nil || uri.to_s.size==0
+      begin
+        u = URI::parse(uri)
+        return (u.scheme!=nil and u.host!=nil)
+      rescue URI::InvalidURIError
+        return false
+      end
+    end
+  end
+  
+#  ['rubygems', 'rest_client'].each do |r|
+#    require r
+#  end
+#  ["bla", "google.de", "http://google.de"].each do |u|
+#    puts u+"? "+Utils.is_uri?(u).to_s
+#  end
+
 end
+

data/lib/validation.rb

@@ -4,8 +4,16 @@ module OpenTox
 		attr_accessor :uri
 
 		def initialize(params)
-			resource = RestClient::Resource.new(params[:uri], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-			@uri = resource.post(params).to_s
+			#resource = RestClient::Resource.new(params[:uri], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
+			#@uri = resource.post(params).body
+			#LOGGER.debug "VALIDATION URI: " + @uri.to_s
+			call = "curl -X POST "
+			params.each do |k,v|
+				call += " -d "+k.to_s+"=\""+URI.encode(v.to_s)+"\"" unless k == :uri
+			end
+			call += " "+params[:uri]
+			LOGGER.debug call
+			@uri = `#{call}`
 		end
 		
 		def self.crossvalidation(params)