t2-server 0.0.4 → 0.1.0

data/lib/t2server/server.rb

@@ -37,6 +37,9 @@ require 'rexml/document'
 include REXML
 
 module T2Server
+
+  # An interface for directly communicating with one or more Taverna 2 Server
+  # instances.
   class Server
     private_class_method :new
     attr_reader :uri, :run_limit
@@ -44,9 +47,11 @@ module T2Server
     # list of servers we know about
     @@servers = []
     
+    # :stopdoc:
+    # New is private but rdoc does not get it right! Hence :stopdoc: section.
     def initialize(uri)
-      @uri = uri
-      uri = URI.parse(uri)
+      @uri = uri.strip_path
+      uri = URI.parse(@uri)
       @host = uri.host
       @port = uri.port
       @base_path = uri.path
@@ -61,7 +66,15 @@ module T2Server
       @runs = {}
       @runs = get_runs
     end
+    # :startdoc:
 
+    # :call-seq:
+    #   Server.connect(uri) -> server
+    #
+    # Connect to the server specified by _uri_ which should be of the form:
+    # http://example.com:8888/blah
+    #
+    # A Server instance is returned that represents the connection.
     def Server.connect(uri)
       # see if we've already got this server
       server = @@servers.find {|s| s.uri == uri}
@@ -74,17 +87,30 @@ module T2Server
       
       server
     end
-    
+
+    # :call-seq:
+    #   server.create_run(workflow) -> run
+    #
+    # Create a run on this server using the specified _workflow_.
     def create_run(workflow)
       uuid = initialize_run(workflow)
       @runs[uuid] = Run.create(self, "", uuid)
     end
-    
+
+    # :call-seq:
+    #   server.initialize_run(workflow) -> string
+    #
+    # Create a run on this server using the specified _workflow_ but do not
+    # return it as a Run instance. Return its UUID instead.
     def initialize_run(workflow)
-      request = Net::HTTP::Post.new("#{@links[:runs]}".gsub("//", "/"))
+      request = Net::HTTP::Post.new("#{@links[:runs]}")
       request.content_type = "application/xml"
-      response = Net::HTTP.new(@host, @port).start do |http|
-        http.request(request, Fragments::WORKFLOW % workflow)
+      begin
+        response = Net::HTTP.new(@host, @port).start do |http|
+          http.request(request, Fragments::WORKFLOW % workflow)
+        end
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
       end
       
       case response
@@ -93,26 +119,39 @@ module T2Server
         epr = URI.parse(response['location'])
         epr.path[-36..-1]
       when Net::HTTPForbidden
-        puts "Sorry, but the server is already running its configured limit of concurrent workflows."
-        puts "Please try again later."
-        ""
+        raise ServerAtCapacityError.new(@run_limit)
       else
-        response_error(response)
-        ""
+        raise UnexpectedServerResponse.new(response)
       end
     end
-    
+
+    # :call-seq:
+    #   server.runs -> [runs]
+    #
+    # Return the set of runs on this server.
     def runs
       get_runs.values
     end
-    
+
+    # :call-seq:
+    #   server.run(uuid) -> run
+    #
+    # Return the specified run.
     def run(uuid)
       get_runs[uuid]
     end
 
+    # :call-seq:
+    #   server.delete_run(uuid) -> bool
+    #
+    # Delete the specified run from the server, discarding all of its state.
     def delete_run(uuid)
-      request = Net::HTTP::Delete.new("#{@links[:runs]}/#{uuid}".gsub("//", "/"))
-      response = Net::HTTP.new(@host, @port).start {|http| http.request(request)}
+      request = Net::HTTP::Delete.new("#{@links[:runs]}/#{uuid}")
+      begin
+        response = Net::HTTP.new(@host, @port).start {|http| http.request(request)}
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
+      end
       
       case response
       when Net::HTTPNoContent
@@ -120,131 +159,183 @@ module T2Server
         @runs.delete(uuid)
         true
       when Net::HTTPNotFound
-        puts "Cannot find run #{run.uuid}."
-        false
+        raise RunNotFoundError.new(uuid)
+      when Net::HTTPForbidden
+        raise AccessForbiddenError.new("run #{uuid}")
       else
-        response_error(response)
+        raise UnexpectedServerResponse.new(response)
       end
     end
-    
+
+    # :call-seq:
+    #   server.delete_all_runs
+    #
+    # Delete all runs on this server, discarding all of their state.
     def delete_all_runs
       # first refresh run list
       runs.each {|run| run.delete}
     end
-    
+
+    # :call-seq:
+    #   server.set_run_input(run, input, value) -> bool
+    #
+    # Set the workflow input port _input_ on run _run_ to _value_.
     def set_run_input(run, input, value)
-      request = Net::HTTP::Put.new("#{@links[:runs]}/#{run.uuid}/#{run.inputs}/input/#{input}".gsub("//", "/"))
-      request.content_type = "application/xml"
-      response = Net::HTTP.new(@host, @port).start do |http|
-        http.request(request, Fragments::RUNINPUTVALUE % value)
-      end
-      
-      case response
-      when Net::HTTPOK
-        # Yay!
-        true
+      path = "#{@links[:runs]}/#{run.uuid}/#{run.inputs}/input/#{input}"
+      set_attribute(path, Fragments::RUNINPUTVALUE % value, "application/xml")
+    rescue AttributeNotFoundError => e
+      if get_runs.has_key? uuid
+        raise e
       else
-        response_error(response)
+        raise RunNotFoundError.new(uuid)
       end
     end
 
+    # :call-seq:
+    #   server.set_run_input_file(run, input, filename) -> bool
+    #
+    # Set the workflow input port _input_ on run _run_ to use the file at
+    # _filename_ for its input.
     def set_run_input_file(run, input, filename)
-      request = Net::HTTP::Put.new("#{@links[:runs]}/#{run.uuid}/#{run.inputs}/input/#{input}".gsub("//", "/"))
-      request.content_type = "application/xml"
-      response = Net::HTTP.new(@host, @port).start do |http|
-        http.request(request, Fragments::RUNINPUTFILE % filename)
-      end
-      
-      case response
-      when Net::HTTPOK
-        # Yay!
-        true
+      path = "#{@links[:runs]}/#{run.uuid}/#{run.inputs}/input/#{input}"
+      set_attribute(path, Fragments::RUNINPUTFILE % filename, "application/xml")
+    rescue AttributeNotFoundError => e
+      if get_runs.has_key? uuid
+        raise e
       else
-        response_error(response)
+        raise RunNotFoundError.new(uuid)
       end
     end
 
+    # :call-seq:
+    #   server.make_run_dir(uuid, root, dir) -> bool
+    #
+    # Create a directory _dir_ within the directory _root_ on the run with
+    # identifier _uuid_. This is mainly for use by Run#mkdir.
     def make_run_dir(uuid, root, dir)
-      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{root}".gsub("//", "/"))
+      raise AccessForbiddenError.new("subdirectories (#{dir})") if dir.include? ?/
+      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{root}")
       request.content_type = "application/xml"
-      response = Net::HTTP.new(@host, @port).start do |http|
-        http.request(request,  Fragments::MKDIR % dir)
+      begin
+        response = Net::HTTP.new(@host, @port).start do |http|
+          http.request(request,  Fragments::MKDIR % dir)
+        end
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
       end
-      
+
       case response
       when Net::HTTPCreated
         # OK, carry on...
         true
-      when Net::HTTPForbidden
-        puts "Error!", response.body
-        false
       when Net::HTTPNotFound
-        puts "Cannot find run #{uuid}."
-        false
+        raise RunNotFoundError.new(uuid)
+      when Net::HTTPForbidden
+        raise AccessForbiddenError.new("#{dir} on run #{uuid}")
       else
-        response_error(response)
+        raise UnexpectedServerResponse.new(response)
       end
     end
-    
+
+    # :call-seq:
+    #   server.upload_run_file(uuid, filename, location, rename) -> string
+    #
+    # Upload a file to the run with identifier _uuid_. Mainly for internal use
+    # by Run#upload_file.
     def upload_run_file(uuid, filename, location, rename)
       contents = Base64.encode64(IO.read(filename))
       rename = filename.split('/')[-1] if rename == ""
-      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{location}".gsub("//", "/"))
+      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{location}")
       request.content_type = "application/xml"
-      response = Net::HTTP.new(@host, @port).start do |http|
-        http.request(request,  Fragments::UPLOAD % [rename, contents])
+      begin
+        response = Net::HTTP.new(@host, @port).start do |http|
+          http.request(request,  Fragments::UPLOAD % [rename, contents])
+        end
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
       end
-      
+
       case response
       when Net::HTTPCreated
         # Success, return remote name of uploaded file
         rename
+      when Net::HTTPNotFound
+        raise RunNotFoundError.new(uuid)
       when Net::HTTPForbidden
-        puts "Error!", response.body
+        raise AccessForbiddenError.new("run #{uuid}")
       else
-        response_error(response)
+        raise UnexpectedServerResponse.new(response)
       end
     end
 
+    # :call-seq:
+    #   server.get_run_attribute(uuid, path) -> string
+    #
+    # Get the attribute at _path_ in the run with identifier _uuid_.
     def get_run_attribute(uuid, path)
       get_attribute("#{@links[:runs]}/#{uuid}/#{path}")
+    rescue AttributeNotFoundError => e
+      if get_runs.has_key? uuid
+        raise e
+      else
+        raise RunNotFoundError.new(uuid)
+      end
     end
 
+    # :call-seq:
+    #   server.set_run_attribute(uuid, path, value) -> bool
+    #
+    # Set the attribute at _path_ in the run with identifier _uuid_ to _value_.
     def set_run_attribute(uuid, path, value)
-      request = Net::HTTP::Put.new("#{@links[:runs]}/#{uuid}/#{path}".gsub("//", "/"))
-      request.content_type = "text/plain"
-      response = Net::HTTP.new(@host, @port).start {|http| http.request(request, value)}
-      
-      case response
-      when Net::HTTPOK
-        # OK, so carry on
-        true
-      when Net::HTTPForbidden
-        puts "Error!"
-        puts response.body
-        false
-      when Net::HTTPNotFound
-        puts "Cannot find run #{uuid}."
-        false
+      set_attribute("#{@links[:runs]}/#{uuid}/#{path}", value, "text/plain")
+    rescue AttributeNotFoundError => e
+      if get_runs.has_key? uuid
+        raise e
       else
-        response_error(response)
+        raise RunNotFoundError.new(uuid)
       end
     end
-    
+
     private
     def get_attribute(path)
-      request = Net::HTTP::Get.new(path.gsub("//", "/"))
-      response = Net::HTTP.new(@host, @port).start {|http| http.request(request)}
-      
+      request = Net::HTTP::Get.new(path)
+      begin
+        response = Net::HTTP.new(@host, @port).start {|http| http.request(request)}
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
+      end
+
       case response
       when Net::HTTPOK
         return response.body
       when Net::HTTPNotFound
-        puts "Cannot find attribute #{path}."
+        raise AttributeNotFoundError.new(path)
       when Net::HTTPForbidden
-        puts "Verboten!"
+        raise AccessForbiddenError.new("attribute #{path}")
       else
-        response_error(response)
+        raise UnexpectedServerResponse.new(response)
+      end
+    end
+
+    def set_attribute(path, value, type)
+      request = Net::HTTP::Put.new(path)
+      request.content_type = type
+      begin
+        response = Net::HTTP.new(@host, @port).start {|http| http.request(request, value)}
+      rescue InternalHTTPError => e
+        raise ConnectionError.new(e)
+      end
+
+      case response
+      when Net::HTTPOK
+        # OK, so carry on
+        true
+      when Net::HTTPNotFound
+        raise AttributeNotFoundError.new(path)
+      when Net::HTTPForbidden
+        raise AccessForbiddenError.new("attribute #{path}")
+      else
+        raise UnexpectedServerResponse.new(response)
       end
     end
 
@@ -258,18 +349,7 @@ module T2Server
         :permlisteners => URI.parse(XPath.first(doc, "//nsr:permittedListeners", nsmap).attributes["href"]).path
       }
     end
-    
-    def response_error(response)
-      puts "Unnexpected response from Taverna Server!"
-      puts "Server is: #{@host}:#{@port}#{@base_path}"
-      puts "Response code is: #{response.code}"
-      if response.body
-        puts "Response body is: \n#{response.body}"
-      end
-      puts "\nRaw error is: \n#{response.error!}"
-      false
-    end
-    
+
     def get_runs
       run_list = get_attribute("#{@links[:runs]}")
 

data/test/tc_paths.rb

@@ -0,0 +1,60 @@
+# Copyright (c) 2010, The University of Manchester, UK.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the names of The University of Manchester nor the names of its
+#    contributors may be used to endorse or promote products derived from this
+#    software without specific prior written permission. 
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: Robert Haines
+
+require 't2server'
+require 'test/unit'
+
+class TestFilePaths < Test::Unit::TestCase
+  def test_standard
+    assert_equal("dir/with/child", "dir/with/child".strip_path)
+    assert_equal("dir/with/child", "/dir/with/child".strip_path)
+    assert_equal("dir/with/child", "dir/with/child/".strip_path)
+    assert_equal("dir/with/child", "/dir/with/child/".strip_path)
+    
+    # make sure it is not stripping in place
+    dir = "/dir/with/child/"
+    dir.strip_path
+    assert_equal("/dir/with/child/", dir)
+  end
+  
+  def test_inplace
+    assert_nil("dir/with/child".strip_path!)
+    assert_not_nil("/dir/with/child".strip_path!)
+    assert_not_nil("dir/with/child/".strip_path!)
+    assert_not_nil("/dir/with/child/".strip_path!)
+    
+    # make sure it is stripping in place
+    dir = "/dir/with/child/"
+    dir.strip_path!
+    assert_equal("dir/with/child", dir)
+  end
+end