t2-server 0.2.1 → 0.5.0

data/README.rdoc

@@ -1,7 +1,7 @@
 = Taverna[http://www.taverna.org.uk/] 2 Server Interaction Gem
 
 Authors::     Robert Haines
-Gem Version:: 0.2.1
+Gem Version:: 0.5.0
 API Version:: 2.2a1
 Contact::     mailto:rhaines@manchester.ac.uk
 URL::         http://taverna.sourceforge.net/
@@ -34,17 +34,22 @@ There are two entry points for the T2Server API:
 * T2Server::Server - Use this if you are providing a web interface to one or
   more Taverna 2 Server instances.
 
+In both cases the gem should be initialized by requiring the top level ruby
+file:
+  require 't2-server.rb'
+
 See the rdoc for more information.
 
 As well as rdoc there are also a couple of example scripts which
 demonstrate good use of the T2Server API. These are available in the
-<tt>bin</tt> directory:
-* run_workflow
-* server_info
-* delete_all_runs
+<tt>bin</tt> directory but are also installed with the library code when the
+gem is installed:
+* t2-run-workflow
+* t2-server-info
+* t2-delete-runs
 Running any of these scripts with a <tt>-h</tt> or <tt>--help</tt>
 switch will show how to use them, e.g.:
-  run_workflow --help
+  t2-run-workflow --help
 
 == Support
 

data/bin/{delete_all_runs → t2-delete-runs}

@@ -31,16 +31,21 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 'rubygems'
+require 't2-server'
 require 'optparse'
 
 # set up options
+delete_all = false
 opts = OptionParser.new do |opt|
-  opt.banner = "Usage: delete_all_runs [options] server-address"
+  opt.banner = "Usage: t2-delete-runs [options] server-address [run-ids...]"
   opt.separator ""
-  opt.separator "  Where server-address is the full URI of the server to"
-  opt.separator "  connect to, e.g.: http://example.com:8080/taverna"
-  opt.separator "  and [options] can be:"
+  opt.separator "  Where server-address is the full URI of the server to connect to,"
+  opt.separator "  e.g.: http://example.com:8080/taverna, run-ids are the id numbers"
+  opt.separator "  of the runs you want to delete and [options] can be:"
+  opt.on("--all", "Delete all runs on the server") do
+    delete_all = true
+  end
   opt.on_tail("-h", "-?", "--help", "Show this message") do
     puts opt
     exit
@@ -55,16 +60,53 @@ end
 # parse options
 opts.parse!
 
-# check for server address
-if ARGV[0] == nil
+# get runs and server address from the arguments
+runs = []
+address = ""
+for arg in ARGV
+  if arg.match(/https?:\/\//) == nil
+    runs << arg
+  else
+    address = arg
+  end
+end
+
+# can't do anything without a server address
+if address == ""
   puts opts
   exit 1
 end
 
-# connect and delete them all!
+# connect...
 begin
-  T2Server::Server.connect(ARGV[0]).delete_all_runs
+  server = T2Server::Server.connect(ARGV[0])
 rescue T2Server::T2ServerError => e
   puts e
   exit 1
 end
+
+# ...and delete them!
+if delete_all
+  begin
+    server.delete_all_runs
+  rescue T2Server::AuthorizationError => ae
+    puts "You are not authorized to delete runs on this server."
+  rescue T2Server::T2ServerError => e
+    puts "There was a problem while deleting runs. Some may remain on the server."
+  end
+else
+  for run in runs
+    begin
+      server.delete_run(run)
+    rescue T2Server::RunNotFoundError => rnf
+      puts "Run '#{run}' not found - skipping."
+      next
+    rescue T2Server::AuthorizationError => ae
+      puts "You are not authorized to delete run '#{run}' - skipping."
+      next
+    rescue T2Server::T2ServerError => e
+      puts "There was a problem while deleting run '#{run}' - skipping."
+      next
+    end
+  end
+end

data/bin/{run_workflow → t2-run-workflow}

@@ -31,39 +31,39 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 'rubygems'
+require 't2-server'
 require 'optparse'
 
 # go through the outputs and either print the contents
 # out or save them to a file.
 # if the output is a list, it appears as a directory so
 # all the individual entries must be grabbed from there.
-def get_outputs(run, pout, dir="")
-  dirs, files = run.ls("out#{dir}")
-  dirs.each {|d| get_outputs(run, pout, "#{dir}/#{d}")}
-  files.each do |out|
-    print "          #{dir}/#{out} -> "
-    data = run.get_output("#{dir}/#{out}")
-    if pout
-      p data
-    else
-      # strip path and convert remove /'s for file output
-      filename = "#{dir.strip_path}/#{out}".gsub('/', '-')
-      File.open(filename, "w") do |file|
-        file.syswrite(data)
-      end
-      puts "written to file: #{filename}"
-    end
+def get_outputs(run, refs)
+  # get a list of the outputs
+  lists, items = run.ls("out")
+
+  # go through the lists
+  lists.each do |l|
+    print "          #{l} -> "
+    p run.get_output("#{l}", refs)
+  end
+
+  # go through the singletons
+  items.each do |i|
+    print "          #{i} -> "
+    p run.get_output("#{i}", refs)
   end
-end  
+end
 
 # set up options
 inputs  = {}
 wkf_file = ""
-print_output = true
+output_refs = false
 baclava_out = ""
+delete_run = false
 opts = OptionParser.new do |opt|
-  opt.banner = "Usage: run_workflow [options] server-address"
+  opt.banner = "Usage: t2-run-workflow [options] server-address"
   opt.separator ""
   opt.separator "  Where server-address is the full URI of the server to"
   opt.separator "  connect to, e.g.: http://example.com:8080/taverna"
@@ -73,7 +73,7 @@ opts = OptionParser.new do |opt|
     wkf_file = val
   end
   opt.on("-i INPUT:VALUE", "--input=INPUT:VALUE", "Set input port INPUT to VALUE") do |val|
-    input, value = val.chomp.split(':')
+    input, value = val.chomp.split(':', 2)
     inputs[input] = value
   end
   opt.on("-b BACLAVA", "--baclava-in=BACLAVA", "Set baclava file for input port values") do |val|
@@ -87,9 +87,14 @@ opts = OptionParser.new do |opt|
       baclava_out = "out.xml"
     end
   end
-  opt.on("-p", "--[no-]print", "Print outputs to the console. On by default " +
-    "unless baclava output is selected") do |val|
-    print_output = val
+  opt.on("-r", "--output-refs", "Return URIs that point to the data items " +
+    "of the output rather than the data items themselves.") do |val|
+    output_refs = val
+  end
+  opt.on("-D", "--delete", "Delete the run from the server when it is " +
+    "complete. By default the run and its results are preserved. Note that " +
+    "the run will still be deleted when its expiry time is reached") do |val|
+    delete_run = val    
   end
   opt.on_tail("-h", "-?", "--help", "Show this message") do
     puts opt
@@ -166,10 +171,12 @@ if exitcd == 0
     puts "Baclava file written to '#{baclava_out}'"
   else
     puts "Outputs:"
-    get_outputs(run, print_output)
+    get_outputs(run, output_refs)
   end
 end
 
-# delete run
-run.delete
-puts "Finished and deleted run"
+# delete run?
+if delete_run
+  run.delete
+  puts "Run deleted"
+end

data/bin/{server_info → t2-server-info}

@@ -31,11 +31,12 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 'rubygems'
+require 't2-server'
 require 'optparse'
 
 opts = OptionParser.new do |opt|
-  opt.banner = "Usage: server_info [options] server-address"
+  opt.banner = "Usage: t2-server-info [options] server-address"
   opt.separator ""
   opt.separator "  Where server-address is the full URI of the server to"
   opt.separator "  connect to, e.g.: http://example.com:8080/taverna"

data/lib/t2-server.rb

@@ -0,0 +1,71 @@
+# 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 't2-server/xml'
+require 't2-server/exceptions'
+require 't2-server/server'
+require 't2-server/run'
+
+# This is a Ruby library to interface with the Taverna 2 Server REST API.
+#
+# There are two API entry points:
+# * T2Server::Run - Use this for running single jobs on a server.
+# * T2Server::Server - Use this if you are providing a web interface to a
+#   Taverna 2 Server instance.
+module T2Server
+  # The version of this library
+  GEM_VERSION = "0.5.0"
+  # The version of the Taverna 2 Server API that this library can interface with
+  API_VERSION = "2.2a1"
+end
+
+# Add methods to the String class to operate on file paths.
+class String
+  # :call-seq:
+  #   str.strip_path -> string
+  #
+  # Returns a new String with one leading and one trailing slash
+  # removed from the ends of _str_ (if present).
+  def strip_path
+    self.gsub(/^\//, "").chomp("/")
+  end
+
+  # :call-seq:
+  #   str.strip_path! -> str or nil
+  #
+  # Modifies _str_ in place as described for String#strip_path,
+  # returning _str_, or returning +nil+ if no modifications were made. 
+  def strip_path!
+    g = self.gsub!(/^\//, "")
+    self.chomp!("/") || g
+  end
+end

data/lib/{t2server → t2-server}/exceptions.rb

@@ -33,11 +33,12 @@
 require 'net/http'
 
 module T2Server
+  # :stopdoc:
   # An internal module to collect all the exceptions that we
   # can't really do anything about ourselves, such as
   # timeouts and lost connections. This is further wrapped
   # and exposed in the API as T2Server::ConnectionError below.
-  module InternalHTTPError  #:nodoc:
+  module InternalHTTPError
   end
 
   # These are the HTTP errors we want to catch.
@@ -55,6 +56,7 @@ module T2Server
     Net::ProtocolError
   ].each {|err| err.send(:include, InternalHTTPError)}
 
+  # :startdoc:
   # This is a superclass for all T2Server exceptions. It is provided as a
   # useful catch-all for all the internally raised/thrown exceptions.
   class T2ServerError < RuntimeError

data/lib/{t2server → t2-server}/run.rb

@@ -30,7 +30,8 @@
 #
 # Author: Robert Haines
 
-require 'rexml/document'
+require 'rubygems'
+require 'libxml'
 
 module T2Server
 
@@ -44,6 +45,8 @@ module T2Server
   # * Finished: The run has finished running and its outputs are available for
   #   download.
   class Run
+    include LibXML
+
     private_class_method :new
 
     # The identifier of this run on the server. It is currently a UUID
@@ -134,18 +137,53 @@ module T2Server
     end
 
     # :call-seq:
-    #   run.get_output(output) -> string
-    #
-    # Return the value of the workflow output port _output_.
-    #
-    # Raises RunStateError if the run is not in the +Finished+ state.
-    def get_output(output, type="text/plain")
-      state = status
-      raise RunStateError.new(state, STATE[:finished]) if state != STATE[:finished]
-
+    #   run.get_output(output, refs=false) -> list
+    #
+    # Return the values of the workflow output port _output_. These are
+    # returned as a list of strings. If the output port represents a singleton
+    # output then a one item list is returned. By default this method returns
+    # the actual data from the output port but if _refs_ is set to true then
+    # it will instead return URIs to the actual data in the same list format.
+    # See also Run#get_output_refs.
+    def get_output(output, refs=false)
       output.strip_path!
-      doc = @server.get_run_attribute(@uuid, "#{@links[:wdir]}/out/#{output}")
-      doc
+      result = []
+
+      # look at the contents of the output port
+      lists, items = ls("out/#{output}")
+
+      # if lists and items are empty then it's a single value
+      if lists == [] and items == []
+        if refs
+          result << "#{@server.uri}/rest/runs/#{@uuid}/#{@links[:wdir]}/out/#{output}"
+        else
+          result << @server.get_run_attribute(@uuid, "#{@links[:wdir]}/out/#{output}")
+        end
+      end
+
+      # for each list recurse into it and add the items to the result
+      lists.each {|list| result << get_output("#{output}/#{list}", refs)}
+
+      # for each item, add it to the output list
+      items.each do |item|
+        if refs
+          result << "#{@server.uri}/rest/runs/#{@uuid}/#{@links[:wdir]}/out/#{output}/#{item}"
+        else
+          result << @server.get_run_attribute(@uuid, "#{@links[:wdir]}/out/#{output}/#{item}")
+        end
+      end
+
+      result
+    end
+
+    # :call-seq:
+    #   run.get_output_refs(output) -> list
+    #
+    # Return references (URIs) to the values of the workflow output port
+    # _output_. These are returned as a list of URIs. If the output port
+    # represents a singleton output then a one item list is returned.
+    def get_output_refs(output)
+      get_output(output, true)
     end
 
     # :call-seq:
@@ -355,19 +393,37 @@ module T2Server
     #   run.ls(dir="") -> [[dirs], [objects]]
     #
     # List a directory in the run's workspace on the server. If _dir_ is left
-    # blank then / is listed. The contents of a directory are returned as a
-    # list of two lists, directories and "objects" respectively.
+    # blank then / is listed. As there is no concept of changing into a
+    # directory (_cd_) in Taverna Server then all paths passed into _ls_
+    # should be full paths starting at "root". The contents of a directory are
+    # returned as a list of two lists, "directories" and "objects"
+    # respectively. In the case of listing the contents of the "out"
+    # directory, the "directories" returned by _ls_ are actually output port
+    # names and their contents are the values held by these ports. If there
+    # are multiple values listed then that port represents a list. If there
+    # are further directories below a port name then it is a list of lists.
     def ls(dir="")
       dir.strip_path!
       dir_list = @server.get_run_attribute(@uuid, "#{@links[:wdir]}/#{dir}")
-      doc = REXML::Document.new(dir_list)
 
       # compile a list of directory entries stripping the
       # directory name from the front of each filename
       dirs = []
       files = []
-      REXML::XPath.each(doc, "//nss:dir", Namespaces::MAP) {|e| dirs << e.text.split('/')[-1]}
-      REXML::XPath.each(doc, "//nss:file", Namespaces::MAP) {|e| files << e.text.split('/')[-1]}
+
+      begin
+        doc = XML::Document.string(dir_list)
+
+        doc.find(XPaths::DIR, Namespaces::MAP).each {|e| dirs << e.content.split('/')[-1]}
+        doc.find(XPaths::FILE, Namespaces::MAP).each {|e| files << e.content.split('/')[-1]}
+      rescue XML::Error => xmle
+        # We expect to get a DOCUMENT_EMPTY error in some cases. All others
+        # should be re-raised.
+        if xmle.code != XML::Error::DOCUMENT_EMPTY
+          raise xmle
+        end
+      end
+
       [dirs, files]
     end
 
@@ -426,9 +482,9 @@ module T2Server
       
       # get inputs
       inputs = @server.get_run_attribute(@uuid, links[:inputs])
-      doc = REXML::Document.new(inputs)
+      doc = XML::Document.string(inputs)
       nsmap = Namespaces::MAP
-      links[:baclava] = "#{links[:inputs]}/" + REXML::XPath.first(doc, "//nsr:baclava", nsmap).attributes["href"].split('/')[-1]
+      links[:baclava] = "#{links[:inputs]}/" + doc.find_first(XPaths::BACLAVA, nsmap).attributes["href"].split('/')[-1]
 
       # set io properties
       links[:io]       = "#{links[:listeners]}/io"
@@ -440,20 +496,20 @@ module T2Server
     end
 
     def parse_description(desc)
-      doc = REXML::Document.new(desc)
+      doc = XML::Document.string(desc)
       nsmap = Namespaces::MAP
       {
-        :expiry     => REXML::XPath.first(doc, "//nsr:expiry", nsmap).attributes["href"].split('/')[-1],
-        :workflow   => REXML::XPath.first(doc, "//nsr:creationWorkflow", nsmap).attributes["href"].split('/')[-1],
-        :status     => REXML::XPath.first(doc, "//nsr:status", nsmap).attributes["href"].split('/')[-1],
-        :createtime => REXML::XPath.first(doc, "//nsr:createTime", nsmap).attributes["href"].split('/')[-1],
-        :starttime  => REXML::XPath.first(doc, "//nsr:startTime", nsmap).attributes["href"].split('/')[-1],
-        :finishtime => REXML::XPath.first(doc, "//nsr:finishTime", nsmap).attributes["href"].split('/')[-1],
-        :wdir       => REXML::XPath.first(doc, "//nsr:workingDirectory", nsmap).attributes["href"].split('/')[-1],
-        :inputs     => REXML::XPath.first(doc, "//nsr:inputs", nsmap).attributes["href"].split('/')[-1],
-        :output     => REXML::XPath.first(doc, "//nsr:output", nsmap).attributes["href"].split('/')[-1],
-        :securectx  => REXML::XPath.first(doc, "//nsr:securityContext", nsmap).attributes["href"].split('/')[-1],
-        :listeners  => REXML::XPath.first(doc, "//nsr:listeners", nsmap).attributes["href"].split('/')[-1]
+        :expiry     => doc.find_first(XPaths::EXPIRY, nsmap).attributes["href"].split('/')[-1],
+        :workflow   => doc.find_first(XPaths::WORKFLOW, nsmap).attributes["href"].split('/')[-1],
+        :status     => doc.find_first(XPaths::STATUS, nsmap).attributes["href"].split('/')[-1],
+        :createtime => doc.find_first(XPaths::CREATETIME, nsmap).attributes["href"].split('/')[-1],
+        :starttime  => doc.find_first(XPaths::STARTTIME, nsmap).attributes["href"].split('/')[-1],
+        :finishtime => doc.find_first(XPaths::FINISHTIME, nsmap).attributes["href"].split('/')[-1],
+        :wdir       => doc.find_first(XPaths::WDIR, nsmap).attributes["href"].split('/')[-1],
+        :inputs     => doc.find_first(XPaths::INPUTS, nsmap).attributes["href"].split('/')[-1],
+        :output     => doc.find_first(XPaths::OUTPUT, nsmap).attributes["href"].split('/')[-1],
+        :securectx  => doc.find_first(XPaths::SECURECTX, nsmap).attributes["href"].split('/')[-1],
+        :listeners  => doc.find_first(XPaths::LISTENERS, nsmap).attributes["href"].split('/')[-1]
       }
     end
   end

data/lib/{t2server → t2-server}/server.rb

@@ -30,16 +30,19 @@
 #
 # Author: Robert Haines
 
+require 'rubygems'
 require 'base64'
 require 'uri'
 require 'net/https'
-require 'rexml/document'
+require 'libxml'
 
 module T2Server
 
   # An interface for directly communicating with one or more Taverna 2 Server
   # instances.
   class Server
+    include LibXML
+
     private_class_method :new
 
     # The URI of this server instance as a String.
@@ -174,11 +177,17 @@ module T2Server
     end
 
     # :call-seq:
-    #   server.delete_run(uuid) -> bool
+    #   server.delete_run(run) -> 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}")
+    # _run_ can be either a Run instance or a UUID.
+    def delete_run(run)
+      # get the uuid from the run if that is what is passed in
+      if run.instance_of? Run
+        run = run.uuid
+      end
+
+      request = Net::HTTP::Delete.new("#{@links[:runs]}/#{run}")
       if ssl?
         request.basic_auth @username, @password
       end
@@ -191,12 +200,12 @@ module T2Server
       case response
       when Net::HTTPNoContent
         # Success, carry on...
-        @runs.delete(uuid)
+        @runs.delete(run)
         true
       when Net::HTTPNotFound
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run)
       when Net::HTTPForbidden
-        raise AccessForbiddenError.new("run #{uuid}")
+        raise AccessForbiddenError.new("run #{run}")
       when Net::HTTPUnauthorized
         raise AuthorizationError.new(@username)
       else
@@ -216,15 +225,21 @@ module T2Server
     # :call-seq:
     #   server.set_run_input(run, input, value) -> bool
     #
-    # Set the workflow input port _input_ on run _run_ to _value_.
+    # Set the workflow input port _input_ on run _run_ to _value_. _run_ can
+    # be either a Run instance or a UUID.
     def set_run_input(run, input, value)
-      path = "#{@links[:runs]}/#{run.uuid}/#{run.inputs}/input/#{input}"
+      # get the run from the uuid if that is what is passed in
+      if not run.instance_of? Run
+        run = run(run)
+      end
+
+      path = "#{@links[:runs]}/#{run.run}/#{run.inputs}/input/#{input}"
       set_attribute(path, Fragments::RUNINPUTVALUE % value, "application/xml")
     rescue AttributeNotFoundError => e
-      if get_runs.has_key? uuid
+      if get_runs.has_key? run.uuid
         raise e
       else
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run.uuid)
       end
     end
 
@@ -232,26 +247,36 @@ module T2Server
     #   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.
+    # _filename_ for its input. _run_ can be either a Run instance or a UUID.
     def set_run_input_file(run, input, filename)
+      # get the run from the uuid if that is what is passed in
+      if not run.instance_of? Run
+        run = run(run)
+      end
+
       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
+      if get_runs.has_key? run.uuid
         raise e
       else
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run.uuid)
       end
     end
 
     # :call-seq:
-    #   server.make_run_dir(uuid, root, dir) -> bool
+    #   server.make_run_dir(run, 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)
+    # Create a directory _dir_ within the directory _root_ on _run_. _run_ can
+    # be either a Run instance or a UUID. This is mainly for use by Run#mkdir.
+    def make_run_dir(run, root, dir)
+      # get the uuid from the run if that is what is passed in
+      if run.instance_of? Run
+        run = run.uuid
+      end
+
       raise AccessForbiddenError.new("subdirectories (#{dir})") if dir.include? ?/
-      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{root}")
+      request = Net::HTTP::Post.new("#{@links[:runs]}/#{run}/#{root}")
       request.content_type = "application/xml"
       if ssl?
         request.basic_auth @username, @password
@@ -267,9 +292,9 @@ module T2Server
         # OK, carry on...
         true
       when Net::HTTPNotFound
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run)
       when Net::HTTPForbidden
-        raise AccessForbiddenError.new("#{dir} on run #{uuid}")
+        raise AccessForbiddenError.new("#{dir} on run #{run}")
       when Net::HTTPUnauthorized
         raise AuthorizationError.new(@username)
       else
@@ -278,14 +303,19 @@ module T2Server
     end
 
     # :call-seq:
-    #   server.upload_run_file(uuid, filename, location, rename) -> string
+    #   server.upload_run_file(run, 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)
+    # Upload a file to _run_. _run_ can be either a Run instance or a UUID.
+    # Mainly for internal use by Run#upload_file.
+    def upload_run_file(run, filename, location, rename)
+      # get the uuid from the run if that is what is passed in
+      if run.instance_of? Run
+        run = run.uuid
+      end
+
       contents = Base64.encode64(IO.read(filename))
       rename = filename.split('/')[-1] if rename == ""
-      request = Net::HTTP::Post.new("#{@links[:runs]}/#{uuid}/#{location}")
+      request = Net::HTTP::Post.new("#{@links[:runs]}/#{run}/#{location}")
       request.content_type = "application/xml"
       if ssl?
         request.basic_auth @username, @password
@@ -301,9 +331,9 @@ module T2Server
         # Success, return remote name of uploaded file
         rename
       when Net::HTTPNotFound
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run)
       when Net::HTTPForbidden
-        raise AccessForbiddenError.new("run #{uuid}")
+        raise AccessForbiddenError.new("run #{run}")
       when Net::HTTPUnauthorized
         raise AuthorizationError.new(@username)
       else
@@ -312,30 +342,42 @@ module T2Server
     end
 
     # :call-seq:
-    #   server.get_run_attribute(uuid, path) -> string
+    #   server.get_run_attribute(run, 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}")
+    # Get the attribute at _path_ in _run_. _run_ can be either a Run instance
+    # or a UUID.
+    def get_run_attribute(run, path)
+      # get the uuid from the run if that is what is passed in
+      if run.instance_of? Run
+        run = run.uuid
+      end
+
+      get_attribute("#{@links[:runs]}/#{run}/#{path}")
     rescue AttributeNotFoundError => e
-      if get_runs.has_key? uuid
+      if get_runs.has_key? run
         raise e
       else
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run)
       end
     end
 
     # :call-seq:
-    #   server.set_run_attribute(uuid, path, value) -> bool
+    #   server.set_run_attribute(run, path, value) -> bool
     #
-    # Set the attribute at _path_ in the run with identifier _uuid_ to _value_.
-    def set_run_attribute(uuid, path, value)
-      set_attribute("#{@links[:runs]}/#{uuid}/#{path}", value, "text/plain")
+    # Set the attribute at _path_ in _run_ to _value_. _run_ can be either a
+    # Run instance or a UUID.
+    def set_run_attribute(run, path, value)
+      # get the uuid from the run if that is what is passed in
+      if run.instance_of? Run
+        run = run.uuid
+      end
+
+      set_attribute("#{@links[:runs]}/#{run}/#{path}", value, "text/plain")
     rescue AttributeNotFoundError => e
-      if get_runs.has_key? uuid
+      if get_runs.has_key? run
         raise e
       else
-        raise RunNotFoundError.new(uuid)
+        raise RunNotFoundError.new(run)
       end
     end
 
@@ -393,24 +435,24 @@ module T2Server
     end
 
     def parse_description(desc)
-      doc = REXML::Document.new(desc)
+      doc = XML::Document.string(desc)
       nsmap = Namespaces::MAP
       {
-        :runs          => URI.parse(REXML::XPath.first(doc, "//nsr:runs", nsmap).attributes["href"]).path,
-        :runlimit      => URI.parse(REXML::XPath.first(doc, "//nsr:runLimit", nsmap).attributes["href"]).path,
-        :permworkflows => URI.parse(REXML::XPath.first(doc, "//nsr:permittedWorkflows", nsmap).attributes["href"]).path,
-        :permlisteners => URI.parse(REXML::XPath.first(doc, "//nsr:permittedListeners", nsmap).attributes["href"]).path
+        :runs          => URI.parse(doc.find_first(XPaths::RUNS, nsmap).attributes["href"]).path,
+        :runlimit      => URI.parse(doc.find_first(XPaths::RUNLIMIT, nsmap).attributes["href"]).path,
+        :permworkflows => URI.parse(doc.find_first(XPaths::PERMWKF, nsmap).attributes["href"]).path,
+        :permlisteners => URI.parse(doc.find_first(XPaths::PERMLSTN, nsmap).attributes["href"]).path
       }
     end
 
     def get_runs
       run_list = get_attribute("#{@links[:runs]}")
 
-      doc = REXML::Document.new(run_list)
+      doc = XML::Document.string(run_list)
 
       # get list of run uuids
       uuids = []
-      REXML::XPath.each(doc, "//nsr:run", Namespaces::MAP) do |run|
+      doc.find(XPaths::RUN, Namespaces::MAP).each do |run|
         uuids << run.attributes["href"].split('/')[-1]
       end
 

data/lib/{t2server → t2-server}/xml.rb

@@ -30,7 +30,11 @@
 #
 # Author: Robert Haines
 
+require 'rubygems'
+require 'libxml'
+
 module T2Server
+  # :stopdoc:
   module Namespaces
     SERVER = "http://ns.taverna.org.uk/2010/xml/server/"
     REST   = SERVER + "rest/"
@@ -39,7 +43,7 @@ module T2Server
       "nsr" => Namespaces::REST
     }
   end
-  
+
   module Fragments
     WORKFLOW      = "<t2s:workflow xmlns:t2s=\"#{Namespaces::SERVER}\">\n  %s\n</t2s:workflow>"
     RUNINPUT      = "<t2sr:runInput xmlns:t2sr=\"#{Namespaces::REST}\">\n  %s\n</t2sr:runInput>"
@@ -48,4 +52,35 @@ module T2Server
     UPLOAD        = "<t2sr:upload xmlns:t2sr=\"#{Namespaces::REST}\" t2sr:name=\"%s\">\n  %s\n</t2sr:upload>"
     MKDIR         = "<t2sr:mkdir xmlns:t2sr=\"#{Namespaces::REST}\" t2sr:name=\"%s\" />"
   end
+
+  module XPaths
+    include LibXML
+
+    # Shut the libxml error handler up
+    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+
+    # Server XPath queries
+    RUN      = XML::XPath::Expression.new("//nsr:run")
+    RUNS     = XML::XPath::Expression.new("//nsr:runs")
+    RUNLIMIT = XML::XPath::Expression.new("//nsr:runLimit")
+    PERMWKF  = XML::XPath::Expression.new("//nsr:permittedWorkflows")
+    PERMLSTN = XML::XPath::Expression.new("//nsr:permittedListeners")
+
+    # Run XPath queries
+    DIR        = XML::XPath::Expression.new("//nss:dir")
+    FILE       = XML::XPath::Expression.new("//nss:file")
+    EXPIRY     = XML::XPath::Expression.new("//nsr:expiry")
+    WORKFLOW   = XML::XPath::Expression.new("//nsr:creationWorkflow")
+    STATUS     = XML::XPath::Expression.new("//nsr:status")
+    CREATETIME = XML::XPath::Expression.new("//nsr:createTime")
+    STARTTIME  = XML::XPath::Expression.new("//nsr:startTime")
+    FINISHTIME = XML::XPath::Expression.new("//nsr:finishTime")
+    WDIR       = XML::XPath::Expression.new("//nsr:workingDirectory")
+    INPUTS     = XML::XPath::Expression.new("//nsr:inputs")
+    OUTPUT     = XML::XPath::Expression.new("//nsr:output")
+    SECURECTX  = XML::XPath::Expression.new("//nsr:securityContext")
+    LISTENERS  = XML::XPath::Expression.new("//nsr:listeners")
+    BACLAVA    = XML::XPath::Expression.new("//nsr:baclava")
+  end
+  # :startdoc:
 end

data/lib/t2server.rb

@@ -30,42 +30,6 @@
 #
 # Author: Robert Haines
 
-require 't2server/xml'
-require 't2server/exceptions'
-require 't2server/server'
-require 't2server/run'
-
-# This is a Ruby library to interface with the Taverna 2 Server REST API.
-#
-# There are two API entry points:
-# * T2Server::Run - Use this for running single jobs on a server.
-# * T2Server::Server - Use this if you are providing a web interface to a
-#   Taverna 2 Server instance.
-module T2Server
-  # The version of this library
-  GEM_VERSION = "0.2.1"
-  # The version of the Taverna 2 Server API that this library can interface with
-  API_VERSION = "2.2a1"
-end
-
-# Add methods to the String class to operate on file paths.
-class String
-  # :call-seq:
-  #   str.strip_path -> string
-  #
-  # Returns a new String with one leading and one trailing slash
-  # removed from the ends of _str_ (if present).
-  def strip_path
-    self.gsub(/^\//, "").chomp("/")
-  end
-
-  # :call-seq:
-  #   str.strip_path! -> str or nil
-  #
-  # Modifies _str_ in place as described for String#strip_path,
-  # returning _str_, or returning +nil+ if no modifications were made. 
-  def strip_path!
-    g = self.gsub!(/^\//, "")
-    self.chomp!("/") || g
-  end
-end
+# This is simply here to provide backwards compatibility. Old versions had an
+# inconsistancy between the gem name and the file to require to use it.
+require 't2-server'

data/test/tc_paths.rb

@@ -30,7 +30,7 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 't2-server'
 require 'test/unit'
 
 class TestFilePaths < Test::Unit::TestCase

data/test/tc_run.rb

@@ -30,7 +30,7 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 't2-server'
 
 class TestRun < Test::Unit::TestCase
 
@@ -41,9 +41,6 @@ class TestRun < Test::Unit::TestCase
     end
 
     # test bad state code
-    assert_raise(T2Server::RunStateError) do
-      @run.get_output("out")
-    end
     assert_raise(T2Server::RunStateError) do
       @run.wait
     end
@@ -61,7 +58,7 @@ class TestRun < Test::Unit::TestCase
 
     # exitcode and output
     assert_instance_of(Fixnum, @run.exitcode)
-    assert_equal(@run.get_output("Message"), "Hello, World!")
+    assert_equal(@run.get_output("Message"), ["Hello, World!"])
     assert_raise(T2Server::AccessForbiddenError) do
       @run.get_output("wrong!")
     end

data/test/tc_server.rb

@@ -30,7 +30,7 @@
 #
 # Author: Robert Haines
 
-require 't2server'
+require 't2-server'
 
 class TestServer < Test::Unit::TestCase
 

data/test/ts_t2server.rb

@@ -31,10 +31,13 @@
 # Author: Robert Haines
 
 require 'test/unit'
-require 't2server'
+require 't2-server'
 
 # get a server address to test - 30 second timeout
-print "\nPlease supply a valid Taverna 2 Server address (leave blank to skip tests): "
+print "\nPlease supply a valid Taverna 2 Server address.\n\nNOTE that these " +
+  "tests will fully load the server and then delete all the runs that it " +
+  "has permission to do so - if you are not using security ALL runs will be " +
+  "deleted!\n(leave blank to skip tests): "
 $stdout.flush
 if select([$stdin], [], [], 30)
   $address = $stdin.gets.chomp

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: t2-server
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Robert Haines
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-23 00:00:00 +01:00
+date: 2010-10-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,24 +34,43 @@ dependencies:
         version: 0.8.7
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 1
+        - 4
+        version: 1.1.4
+  type: :runtime
+  version_requirements: *id002
 description: This gem provides access to the Taverna 2 Server REST interface from Ruby.
 email: rhaines@manchester.ac.uk
-executables: []
-
+executables: 
+- t2-delete-runs
+- t2-run-workflow
+- t2-server-info
 extensions: []
 
 extra_rdoc_files: 
 - README.rdoc
 - LICENCE
 files: 
-- bin/server_info
-- bin/run_workflow
-- bin/delete_all_runs
+- bin/t2-server-info
+- bin/t2-delete-runs
+- bin/t2-run-workflow
 - lib/t2server.rb
-- lib/t2server/server.rb
-- lib/t2server/exceptions.rb
-- lib/t2server/xml.rb
-- lib/t2server/run.rb
+- lib/t2-server/server.rb
+- lib/t2-server/exceptions.rb
+- lib/t2-server/xml.rb
+- lib/t2-server/run.rb
+- lib/t2-server.rb
 - test/tc_server.rb
 - test/tc_paths.rb
 - test/tc_run.rb
@@ -64,8 +83,10 @@ homepage: http://www.taverna.org.uk/
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- -N
+- --tab-width=2
+- --main=README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement