opentox-ruby 0.0.2 → 1.0.0

data/lib/rest_client_wrapper.rb

@@ -1,32 +1,4 @@
 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.to_s[0..1000]
-      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
@@ -34,45 +6,80 @@ module OpenTox
   
   class RestClientWrapper
     
-    def self.get(uri, headers=nil, wait=true)
-      execute( "get", uri, headers, nil, wait)
+    # performs a GET REST call
+    # raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502)
+    # per default: waits for Task to finish and returns result URI of Task
+    # @param [String] uri destination URI
+    # @param [optional,Hash] headers contains params like accept-header
+    # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @param [wait,Boolean] wait set to false to NOT wait for task if result is task
+    # @return [OpenTox::WrapperResult] a String containing the result-body of the REST call
+    def self.get(uri, headers={}, waiting_task=nil, wait=true )
+      execute( "get", uri, nil, headers, waiting_task, wait)
     end
     
-    def self.post(uri, headers, payload=nil, wait=true)
-      execute( "post", uri, headers, payload, wait )
+    # performs a POST REST call
+    # raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502)
+    # per default: waits for Task to finish and returns result URI of Task
+    # @param [String] uri destination URI
+    # @param [optional,String] payload data posted to the service
+    # @param [optional,Hash] headers contains params like accept-header
+    # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @param [wait,Boolean] wait set to false to NOT wait for task if result is task
+    # @return [OpenTox::WrapperResult] a String containing the result-body of the REST call
+    def self.post(uri, payload=nil, headers={}, waiting_task=nil, wait=true )
+      execute( "post", uri, payload, headers, waiting_task, wait )
     end
     
-    def self.put(uri, headers, payload=nil )
-      execute( "put", uri, headers, payload )
+    # performs a PUT REST call
+    # raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502)
+    # @param [String] uri destination URI
+    # @param [optional,Hash] headers contains params like accept-header
+    # @param [optional,String] payload data put to the service
+    # @return [OpenTox::WrapperResult] a String containing the result-body of the REST call
+    def self.put(uri, payload=nil, headers={} )
+      execute( "put", uri, payload, headers )
     end
 
-    def self.delete(uri, headers=nil)
-      execute( "delete", uri, headers, nil)
+    # performs a DELETE REST call
+    # raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502)
+    # @param [String] uri destination URI
+    # @param [optional,Hash] headers contains params like accept-header
+    # @return [OpenTox::WrapperResult] a String containing the result-body of the REST call
+    def self.delete(uri, headers=nil )
+      execute( "delete", uri, nil, headers)
     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 )
+    def self.execute( rest_call, uri, payload=nil, headers={}, waiting_task=nil, wait=true )
       
-      do_halt 400,"uri is null",uri,headers,payload unless uri
-      do_halt 400,"not a uri",uri,headers,payload unless uri.to_s.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
+      raise OpenTox::BadRequestError.new "uri is null" unless uri
+      raise OpenTox::BadRequestError.new "not a uri: "+uri.to_s unless uri.to_s.uri?
+      raise "headers are no hash: "+headers.inspect unless headers==nil or headers.is_a?(Hash)
+      raise OpenTox::BadRequestError.new "accept should go into the headers" if payload and payload.is_a?(Hash) and payload[:accept] 
+      raise OpenTox::BadRequestError.new "content_type should go into the headers" if payload and payload.is_a?(Hash) and payload[:content_type]
+      raise "__waiting_task__ must be 'nil' or '(sub)task', is "+waiting_task.class.to_s if
+        waiting_task!=nil and !(waiting_task.is_a?(Task) || waiting_task.is_a?(SubTask))
       headers.each{ |k,v| headers.delete(k) if v==nil } if headers #remove keys with empty values, as this can cause problems
+      ## PENDING partner services accept subjectid only in header
+      headers = {} unless headers
+      headers[:subjectid] = payload.delete(:subjectid) if payload and payload.is_a?(Hash) and payload.has_key?(:subjectid) 
+      
+      # PENDING needed for NUTA, until we finally agree on how to send subjectid
+      headers[:subjectid] = payload.delete(:subjectid) if uri=~/ntua/ and payload and payload.is_a?(Hash) and payload.has_key?(:subjectid) 
       
       begin
-        #LOGGER.debug "RestCall: "+rest_call.to_s+" "+uri.to_s+" "+headers.inspect
-        resource = RestClient::Resource.new(uri,{:timeout => 60}) 
-        if payload
+        #LOGGER.debug "RestCall: "+rest_call.to_s+" "+uri.to_s+" "+headers.inspect+" "+payload.inspect
+        resource = RestClient::Resource.new(uri,{:timeout => 60})
+        if rest_call=="post" || rest_call=="put"
           result = resource.send(rest_call, payload, headers)
-        elsif headers
-          result = resource.send(rest_call, headers)
         else
-          result = resource.send(rest_call)
+          result = resource.send(rest_call, headers)
         end
+        #LOGGER.debug "result body size: #{result.body.size}"
+
+        # PENDING NTUA does return errors with 200
+        raise RestClient::ExceptionWithResponse.new(result) if uri=~/ntua/ and result.body =~ /about.*http:\/\/anonymous.org\/error/
         
         # result is a string, with the additional fields content_type and code
         res = WrapperResult.new(result.body)
@@ -84,29 +91,31 @@ module OpenTox
         return res if res.code==200 || !wait
         
         while (res.code==201 || res.code==202)
-          res = wait_for_task(res, uri)
+          res = wait_for_task(res, uri, waiting_task)
         end
         raise "illegal status code: '"+res.code.to_s+"'" unless res.code==200
         return res
         
       rescue RestClient::RequestTimeout => ex
-        do_halt 408,ex.message,uri,headers,payload
+        received_error ex.message, 408, nil, {:rest_uri => uri, :headers => headers, :payload => payload}
+      rescue Errno::ECONNREFUSED => ex
+        received_error ex.message, 500, nil, {:rest_uri => uri, :headers => headers, :payload => payload}
+      rescue RestClient::ExceptionWithResponse => ex
+        # error comming from a different webservice, 
+        received_error ex.http_body, ex.http_code, ex.response.net_http_res.content_type, {:rest_uri => uri, :headers => headers, :payload => payload}
+      rescue OpenTox::RestCallError => ex
+        # already a rest-error, probably comes from wait_for_task, just pass through
+        raise ex       
       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
+        # some internal error occuring in rest_client_wrapper, just pass through
+        raise ex
       end
     end
     
-    def self.wait_for_task( res, base_uri )
-                          
+    def self.wait_for_task( res, base_uri, waiting_task=nil )
+      #TODO remove TUM hack
+      res.content_type = "text/uri-list" if base_uri =~/tu-muenchen/ and res.content_type == "application/x-www-form-urlencoded;charset=UTF-8"
+
       task = nil
       case res.content_type
       when /application\/rdf\+xml/
@@ -115,53 +124,55 @@ module OpenTox
         task = OpenTox::Task.from_yaml(res)
       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 res.to_s.uri?
+        task = OpenTox::Task.find(res.to_s.chomp) if res.to_s.uri?
       else
-        raise "unknown content-type for task: '"+res.content_type.to_s+"'" #+"' content: "+res[0..200].to_s
+        raise "unknown content-type for task : '"+res.content_type.to_s+"'"+" base-uri: "+base_uri.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
-      
+      task.wait_for_completion waiting_task
+      unless task.completed? # maybe task was cancelled / error
+        if task.errorReport
+          received_error task.errorReport, task.http_code, nil, {:rest_uri => task.uri, :rest_code => task.http_code}
+        else
+          raise "task status: '"+task.status.to_s+"' but errorReport nil"
+        end 
+      end
+    
       res = WrapperResult.new task.result_uri
       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)]
+    def self.received_error( body, code, content_type=nil, params=nil )
+
+      # try to parse body
+      report = nil
+      if body.is_a?(OpenTox::ErrorReport)
+        report = body
       else
-        error = [Error.new(code, body, uri, payload, headers)]
+        case content_type
+        when /yaml/
+           report = YAML.load(body)
+        when /rdf/
+           report = OpenTox::ErrorReport.from_rdf(body)
+        end
       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.create 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.create
-      #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
+      unless report
+		    # parsing was not successfull
+        # raise 'plain' RestCallError
+        err = OpenTox::RestCallError.new("REST call returned error: '"+body.to_s+"'")
+        err.rest_params = params
+        raise err
+      else
+        # parsing sucessfull
+        # raise RestCallError with parsed report as error cause
+        err = OpenTox::RestCallError.new("REST call subsequent error")
+        err.errorCause = report
+        err.rest_params = params
+        raise err
       end
     end
   end

data/lib/serializer.rb

@@ -14,7 +14,7 @@ module OpenTox
       def initialize
 
         @object = {
-          # this should come from opntox.owl
+          # this should come from opentox.owl
           OT.Compound => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.Feature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.NominalFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
@@ -26,6 +26,16 @@ module OpenTox
           OT.Algorithm => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.Parameter => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.Task => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          #classes for validation
+          OT.Validation => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.ClassificationStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.ConfusionMatrix => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.ConfusionMatrixCell => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.ClassValueStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.RegressionStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Crossvalidation => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.CrossvalidationInfo => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.ErrorReport => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
 
           OT.compound => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
           OT.feature => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
@@ -34,6 +44,22 @@ module OpenTox
           OT.values => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
           OT.algorithm => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
           OT.parameters => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          #object props for validation#           
+          OT.model => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.trainingDataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.predictionFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.predictionDataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.crossvalidation => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.testTargetDataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.testDataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.classificationStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.confusionMatrix => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.confusionMatrixCell => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.classValueStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.regressionStatistics => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.validation => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.crossvalidationInfo => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.dataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
 
           DC.title => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           DC.identifier => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
@@ -47,6 +73,51 @@ module OpenTox
           OT.hasStatus => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.resultURI => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.percentageCompleted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          # annotation props for validation        
+          OT.numUnpredicted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.crossvalidationFold => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numInstances => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numWithoutClass => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.percentWithoutClass => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.percentUnpredicted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.confusionMatrixActual => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.confusionMatrixPredicted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.confusionMatrixValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numIncorrect => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.percentCorrect => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numCorrect => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.accuracy => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.trueNegativeRate => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.truePositiveRate => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.falseNegativeRate => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.falsePositiveRate => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numTrueNegatives => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numTruePositives => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numFalseNegatives => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numFalsePositives => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.classValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.precision => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.areaUnderRoc => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.weightedAreaUnderRoc => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.fMeasure => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.percentIncorrect => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.validationType => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.realRuntime => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.sampleCorrelationCoefficient => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.targetVarianceActual => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.targetVariancePredicted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.meanAbsoluteError => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.sumSquaredError => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.rootMeanSquaredError => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.rSquare => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.stratified => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.numFolds => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.randomSeed => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.reportType => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.message => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.statusCode => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.actor => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.errorCode => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
 
           OT.hasSource => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
           OT.value => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
@@ -121,6 +192,64 @@ module OpenTox
         @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Task }] }
         add_metadata uri, metadata
       end
+      
+      # Add a resource defined by resource_class and content
+      # (see documentation of add_content for example)
+      # @param [String] uri of resource
+      # @param [String] resource class, e.g. OT.Validation
+      # @param [Hash] content as hash
+      def add_resource(uri, resource_class, content)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => resource_class }] }
+        @@content_id = 1
+        add_content uri, content
+      end
+      
+      private
+      @@content_id = 1
+      
+      # Recursiv function to add content
+      # @example
+      # { DC.description => "bla",
+      #   OT.similar_resources => [ "http://uri1", "http://uri2" ],
+      #   OT.matrixCells => 
+      #     [ { RDF.type => OT.MatrixCell, OT.cellIndex=1 OT.cellValue => "xy" },
+      #       { RDF.type => OT.MatrixCell, OT.cellIndex=2 OT.cellValue => "z" } ],
+      #   OT.info => { RDF.type => OT.ImportantInfo, 
+      #                DC.description => "blub" }
+      # } 
+      # @param [String] uri
+      # @param [Hash] content as hash, uri must already have been added to @object
+      def add_content(uri, hash)
+        raise "content is no hash: "+hash.class.to_s unless hash.is_a?(Hash)
+        hash.each do |u,v|
+          if v.is_a? Hash
+            # value is again a hash, i.e. a new owl class is added
+            # first make sure type (==class) is set 
+            type = v[RDF.type]
+            raise "type missing for "+u.to_s+" content:\n"+v.inspect unless type
+            raise "class unknown "+type.to_s+" (for "+u.to_s+")" unless @object.has_key?(type)
+            # create new node and add to current uri
+            genid = "_:#{type.split('#')[-1]}#{@@content_id}"
+            @@content_id += 1
+            @object[uri] = {} unless @object[uri]
+            @object[uri][u] = [{ "type" => "bnode", "value" => genid }]
+            # add content to new class
+            add_content(genid,v)
+          elsif v.is_a? Array
+            # value is an array, i.e. a list of values with property is added 
+            v.each{ |vv| add_content( uri, { u => vv } ) }
+          else # v.is_a? String
+            # simple string value
+            @object[uri] = {} unless @object[uri]
+            @object[uri][u] = [] unless @object[uri][u]
+            raise "property unknown "+u.to_s if !@object.has_key?(u) and u!=RDF.type
+            # use << to allow different values for one property
+            @object[uri][u] << {"type" => type(v), "value" => v }
+          end
+        end
+      end
+      
+      public
 
       # Add metadata
       # @param [Hash] metadata

data/lib/task.rb

@@ -1,4 +1,3 @@
-$self_task=nil
 
 module OpenTox
 
@@ -13,7 +12,7 @@ module OpenTox
         DC.title => "",
         DC.date => "",
         OT.hasStatus => "Running",
-        OT.percentageCompleted => "0",
+        OT.percentageCompleted => 0.0,
         OT.resultURI => "",
         DC.creator => "", # not mandatory according to API
         DC.description => "", # not mandatory according to API
@@ -34,7 +33,7 @@ module OpenTox
     def self.create( title=nil, creator=nil, max_duration=DEFAULT_TASK_MAX_DURATION, description=nil )
       
       params = {:title=>title, :creator=>creator, :max_duration=>max_duration, :description=>description }
-      task_uri = RestClientWrapper.post(CONFIG[:services]["opentox-task"], params, nil, false).to_s
+      task_uri = RestClientWrapper.post(CONFIG[:services]["opentox-task"], params, {}, nil, false).to_s
       task = Task.new(task_uri.chomp)
 
       # measure current memory consumption
@@ -49,34 +48,24 @@ module OpenTox
 
       cpu_load = `cat /proc/loadavg`.split(/\s+/)[0..2].collect{|c| c.to_f}
       nr_cpu_cores = `cat /proc/cpuinfo |grep "cpu cores"|cut -d ":" -f2|tr -d " "`.split("\n").collect{|c| c.to_i}.inject{|sum,n| sum+n}
-      if cpu_load[0] > nr_cpu_cores and cpu_load[0] > cpu_load[1] and cpu_load[1] > cpu_load[2] # average CPU load of the last minute is high and CPU load is increasing
-        LOGGER.warn "Cannot start task  - CPU load too high (#{cpu_load.join(", ")})"
-        task.cancel
-        return task
-        #raise "Server too busy to start a new task"
-      end
-
+      nr_cpu_cores = 1 if !nr_cpu_cores
+      #if cpu_load[0] > nr_cpu_cores and cpu_load[0] > cpu_load[1] and cpu_load[1] > cpu_load[2] # average CPU load of the last minute is high and CPU load is increasing
+      #  LOGGER.warn "Cannot start task  - CPU load too high (#{cpu_load.join(", ")})"
+      #  task.cancel
+      #  return task
+      #  #raise "Server too busy to start a new task"
+      #end
 
       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
+          result = yield task
           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)
+        rescue => error
+          LOGGER.error "task failed: "+error.class.to_s+": "+error.message
+          LOGGER.error ":\n"+error.backtrace.join("\n")
+          task.error(OpenTox::ErrorReport.create(error, creator))
         end
       end  
       task.pid = task_pid
@@ -88,11 +77,23 @@ module OpenTox
     # @param [String] uri Task URI
     # @return [OpenTox::Task] Task object
     def self.find(uri)
+      return nil unless uri
       task = Task.new(uri)
       task.load_metadata
+      raise "could not load task metadata" if task.metadata==nil or task.metadata.size==0
       task
     end
 
+    # Find a task for querying, status changes
+    # @param [String] uri Task URI
+    # @return [OpenTox::Task] Task object
+    def self.exist?(uri)
+      begin
+        return find(uri)
+      rescue
+      end 
+    end
+
     # Get a list of all tasks
     # @param [optional, String] uri URI of task service
     # @return [text/uri-list] Task URIs
@@ -103,16 +104,19 @@ module OpenTox
     def self.from_yaml(yaml)
       @metadata = YAML.load(yaml)
     end
-
+    
     def self.from_rdfxml(rdfxml)
-      file = Tempfile.open("ot-rdfxml"){|f| f.write(rdfxml)}.path
-      parser = Parser::Owl::Generic.new file
-      @metadata = parser.load_metadata
+      owl = OpenTox::Parser::Owl.from_rdf(rdfxml, OT.Task)
+      task = Task.new(owl.uri)
+      task.add_metadata(owl.metadata)
+      task
     end
 
     def to_rdfxml
       s = Serializer::Owl.new
+      @metadata[OT.errorReport] = @uri+"/ErrorReport/tmpId" if @error_report
       s.add_task(@uri,@metadata)
+      s.add_resource(@uri+"/ErrorReport/tmpId", OT.errorReport, @error_report.rdf_content) if @error_report
       s.to_rdfxml
     end
 
@@ -128,8 +132,12 @@ module OpenTox
       @metadata[DC.description]
     end
     
+    def errorReport
+      @metadata[OT.errorReport]
+    end
+    
     def cancel
-      RestClientWrapper.put(File.join(@uri,'Cancelled'))
+      RestClientWrapper.put(File.join(@uri,'Cancelled'),{:cannot_be => "empty"})
       load_metadata
     end
 
@@ -138,11 +146,17 @@ module OpenTox
       load_metadata
     end
 
-    def error(description)
-      RestClientWrapper.put(File.join(@uri,'Error'),{:description => description.to_s[0..2000]})
+    def error(error_report)
+      raise "no error report" unless error_report.is_a?(OpenTox::ErrorReport)
+      RestClientWrapper.put(File.join(@uri,'Error'),{:errorReport => error_report.to_yaml})
       load_metadata
     end
     
+    # not stored just for to_rdf
+    def add_error_report( error_report )
+      @error_report = error_report
+    end
+    
     def pid=(pid)
       RestClientWrapper.put(File.join(@uri,'pid'), {:pid => pid})
     end
@@ -160,19 +174,20 @@ module OpenTox
     end
 
     def load_metadata
-      if (CONFIG[:yaml_hosts].include?(URI.parse(uri).host))
-        result = RestClientWrapper.get(@uri, {:accept => 'application/x-yaml'}, false)
+      if (CONFIG[:yaml_hosts].include?(URI.parse(@uri).host))
+        result = RestClientWrapper.get(@uri, {:accept => 'application/x-yaml'}, nil, false)
         @metadata = YAML.load result.to_s
         @http_code = result.code
       else
         @metadata = Parser::Owl::Generic.new(@uri).load_metadata
-        @http_code = RestClientWrapper.get(uri, {:accept => 'application/rdf+xml'}, false).code
+        @http_code = RestClientWrapper.get(uri, {:accept => 'application/rdf+xml'}, nil, false).code
       end
+      raise "could not load task metadata for task "+@uri.to_s if @metadata==nil || @metadata.size==0
     end
     
     # create is private now, use OpenTox::Task.as_task
     #def self.create( params )
-      #task_uri = RestClientWrapper.post(CONFIG[:services]["opentox-task"], params, nil, false).to_s
+      #task_uri = RestClientWrapper.post(CONFIG[:services]["opentox-task"], params, {}, false).to_s
       #Task.find(task_uri.chomp)
     #end
     
@@ -217,8 +232,11 @@ module OpenTox
 =end
 
     # waits for a task, unless time exceeds or state is no longer running
-    def wait_for_completion(dur=0.3)
+    # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @param [optional,Numeric] dur seconds pausing before cheking again for completion
+    def wait_for_completion( waiting_task=nil, dur=0.3)
       
+      waiting_task.waiting_for(self.uri) if waiting_task
       due_to_time = Time.new + DEFAULT_TASK_MAX_DURATION
       LOGGER.debug "start waiting for task "+@uri.to_s+" at: "+Time.new.to_s+", waiting at least until "+due_to_time.to_s
       
@@ -227,21 +245,42 @@ module OpenTox
       while self.running?
         sleep dur
         load_metadata 
+        # if another (sub)task is waiting for self, set progress accordingly 
+        waiting_task.progress(@metadata[OT.percentageCompleted].to_f) if waiting_task
         check_state
         if (Time.new > due_to_time)
           raise "max wait time exceeded ("+DEFAULT_TASK_MAX_DURATION.to_s+"sec), task: '"+@uri.to_s+"'"
         end
       end
-      
-      LOGGER.debug "Task '"+@metadata[OT.hasStatus]+"': "+@uri.to_s+", Result: "+@metadata[OT.resultURI].to_s
+      waiting_task.waiting_for(nil) if waiting_task
+      LOGGER.debug "Task '"+@metadata[OT.hasStatus].to_s+"': "+@uri.to_s+", Result: "+@metadata[OT.resultURI].to_s
     end
-  
+    
+    # updates percentageCompleted value (can only be increased)
+    # task has to be running 
+    # @param [Numeric] pct value between 0 and 100
+    def progress(pct)
+      #puts "task := "+pct.to_s
+      raise "no numeric >= 0 and <= 100 : '"+pct.to_s+"'" unless pct.is_a?(Numeric) and pct>=0 and pct<=100
+      if (pct > @metadata[OT.percentageCompleted] + 0.0001)
+        RestClientWrapper.put(File.join(@uri,'Running'),{:percentageCompleted => pct})
+        load_metadata
+      end
+    end
+    
+    def waiting_for(task_uri)
+      RestClientWrapper.put(File.join(@uri,'Running'),{:waiting_for => task_uri})
+    end
+    
     private
+    VALID_TASK_STATES = ["Cancelled", "Completed", "Running", "Error"]
+    
     def check_state
       begin
+        raise "illegal task state, invalid status: '"+@metadata[OT.hasStatus].to_s+"'" unless 
+          @metadata[OT.hasStatus] unless VALID_TASK_STATES.include?(@metadata[OT.hasStatus])
         raise "illegal task state, task is completed, resultURI is no URI: '"+@metadata[OT.resultURI].to_s+
             "'" unless @metadata[OT.resultURI] and @metadata[OT.resultURI].to_s.uri? if completed?
-        
         if @http_code == 202
           raise "#{@uri}: illegal task state, code is 202, but hasStatus is not Running: '"+@metadata[OT.hasStatus]+"'" unless running?
         elsif @http_code == 201
@@ -250,10 +289,108 @@ module OpenTox
               "'" unless @metadata[OT.resultURI] and @metadata[OT.resultURI].to_s.uri?
         end
       rescue => ex
-        RestClientWrapper.raise_uri_error(ex.message, @uri)
+        raise OpenTox::BadRequestError.new ex.message+" (task-uri:"+@uri+")" 
       end
     end
+  end
+
+  # Convenience class to split a (sub)task into subtasks
+  #
+  # example:
+  # a crossvalidation is split into creating datasets and performing the validations
+  # creating the dataset is 1/3 of the work, perform the validations is 2/3:
+  # Task.as_task do |task|
+  #   create_datasets( SubTask.new(task, 0, 33) )
+  #   perfom_validations( SubTask.new(task, 33, 100) )
+  # end
+  # inside the create_datasets / perform_validations you can use subtask.progress(<val>)
+  # with vals from 0-100
+  #
+  # note that you can split a subtask into further subtasks
+  class SubTask
+    
+    def initialize(task, min, max)
+      raise "not a task or subtask" if task!=nil and !(task.is_a?(Task) or task.is_a?(SubTask)) 
+      raise "invalid max ("+max.to_s+"), min ("+min.to_s+") params" unless 
+        min.is_a?(Numeric) and max.is_a?(Numeric) and min >= 0 and max <= 100 and max > min 
+      @task = task
+      @min = min
+      @max = max
+      @delta = max - min
+    end
+
+    # convenience method to handle null tasks
+    def self.create(task, min, max)
+      if task
+        SubTask.new(task, min, max)
+      else
+        nil
+      end
+    end
+    
+    def waiting_for(task_uri)
+      @task.waiting_for(task_uri)
+    end
+    
+    def progress(pct)
+      raise "no numeric >= 0 and <= 100 : '"+pct.to_s+"'" unless pct.is_a?(Numeric) and pct>=0 and pct<=100
+      #puts "subtask := "+pct.to_s+" -> task := "+(@min + @delta * pct.to_f * 0.01).to_s
+      @task.progress( @min + @delta * pct.to_f * 0.01 )
+    end
+    
+    def running?()
+      @task.running?
+    end
+  end
 
+  
+  # The David Gallagher feature:
+  # a fake sub task to keep the progress bar movin for external jobs
+  # note: param could be a subtask
+  # 
+  # usage (for a call that is normally finished in under 60 seconds):
+  #   fsk = FakeSubTask.new(task, 60)
+  #   external_lib_call.start
+  #   external_lib_call.wait_until_finished
+  #   fsk.finished
+  #   
+  # what happens: 
+  # the FakeSubTask updates the task.progress each second until 
+  # runtime is up or the finished mehtod is called 
+  # 
+  # example if the param runtime is too low:
+  #   25% .. 50% .. 75% .. 100% .. 100% .. 100% .. 100% .. 100%
+  # example if the param runtime is too high:
+  #    5% .. 10% .. 15% ..  20% ..  25% ..  30% ..  35% .. 100%
+  # the latter example is better (keep the bar movin!) 
+  # -> better make a conservative runtime estimate 
+  class FakeSubTask
+    
+    def initialize(task, runtime)
+      @task = task
+      @thread = Thread.new do
+        timeleft = runtime
+        while (timeleft > 0 and @task.running?)
+          sleep 1
+          timeleft -= 1
+          @task.progress( (runtime - timeleft) / runtime.to_f * 100 )
+        end
+      end
+    end
+    
+    # convenience method to handle null tasks
+    def self.create(task, runtime)
+      if task
+        FakeSubTask.new(task, runtime)
+      else
+        nil
+      end
+    end
+  
+    def finished
+      @thread.exit
+      @task.progress(100) if @task.running?
+    end
   end
 
 end