taverna-player 0.1.0

data/lib/taverna_player/engine.rb

@@ -0,0 +1,23 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  class Engine < ::Rails::Engine
+    isolate_namespace TavernaPlayer
+
+    initializer "taverna_player.action_controller" do
+      ActiveSupport.on_load :action_controller do
+        helper TavernaPlayer::ApplicationHelper
+      end
+    end
+  end
+end

data/lib/taverna_player/model_proxy.rb

@@ -0,0 +1,51 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  class ModelProxy
+    attr_reader :class_name
+
+    def initialize(class_name, method_names = [])
+      if class_name.is_a?(String)
+        begin
+          @class_name = Object.const_get(class_name)
+        rescue NameError
+          @class_name = class_name.constantize
+        end
+      end
+
+      method_names.each do |name|
+        add_method(name.to_sym)
+      end
+    end
+
+    private
+
+    def add_method(name)
+      setter = "#{name}_method_name=".to_sym
+      mapper = name
+
+      (class << self; self; end).instance_eval do
+        # Define the method to use the mapped method on the object.
+        define_method name do |object|
+          mapper.nil? ? nil : object.send(mapper)
+        end
+
+        # Define the method used to set the mapped method's name.
+        define_method setter do |method_name|
+          mapper = method_name.nil? ? nil : method_name.to_sym
+        end
+      end
+    end
+
+  end
+end

data/lib/taverna_player/output_renderer.rb

@@ -0,0 +1,96 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+
+  # This class manages the rendering of many different output types that could
+  # be produced by a workflow. It can be configured with new types and the
+  # example renderers for each type can also be changed. An example of how to
+  # set it up can be found in the taverna_player initializer.
+  #
+  # Each renderer has all of the ActionView::Helpers (such as link_to, tag,
+  # etc) available to them.
+  class OutputRenderer
+    # The renderers are all called in the scope of this class so we include
+    # ActionView::Helpers here so that they are all available to them.
+    include ActionView::Helpers
+
+    # :stopdoc:
+    # Taverna Workflow error MIME type
+    TAVERNA_ERROR_TYPE = MIME::Type.new("application/x-error")
+
+    # Empty file MIME types as used in older and new versions of "file".
+    EMPTY_FILE_OLD = MIME::Type.new("application/x-empty")
+    EMPTY_FILE_NEW = MIME::Type.new("inode/x-empty")
+
+    def initialize
+      @hash = Hash.new
+      MIME::Types.add(TAVERNA_ERROR_TYPE, EMPTY_FILE_OLD, EMPTY_FILE_NEW)
+    end
+    # :startdoc:
+
+    # :call-seq:
+    #   add(mimetype, renderer, default = false)
+    #
+    # Add a renderer method for the specified MIME type. If you would like the
+    # renderer to be the default for that particular media type then pass true
+    # in the final parameter - the media type is the part of a MIME type before
+    # the slash (/), e.g. "text" or "image". The MIME type should be specified
+    # as a string.
+    def add(mimetype, method, default = false)
+      type = MIME::Types[mimetype].first
+
+      @hash[type.media_type] ||= {}
+      @hash[type.media_type][type.sub_type] = method
+      @hash[type.media_type][:default] = method if default
+    end
+
+    # :call-seq:
+    #   type_default(media_type, renderer)
+    #
+    # This is another way of setting the default renderer method for a whole
+    # media type (see the add method for more details).
+    def type_default(media_type, method)
+      @hash[media_type] ||= {}
+      @hash[media_type][:default] = method
+    end
+
+    # :call-seq:
+    #   default(method)
+    #
+    # Set a default renderer for any MIME type not specifically set. This
+    # could be used to supply a piece of text and a download link for any type
+    # that cannot normally be shown in the browser inline.
+    def default(method)
+      @hash[:default] = method
+    end
+
+    # :call-seq:
+    #   render(content, mimetype) -> markup
+    #
+    # This is the method that calls the correct renderer for the given content
+    # with the given MIME type and returns the resultant rendering.
+    def render(content, mimetype)
+      type = MIME::Types[mimetype].first
+
+      renderer = @hash[type.media_type][type.sub_type] ||
+        @hash[type.media_type][:default] || @hash[:default]
+
+      if renderer.is_a? Proc
+        renderer.call(content, type)
+      else
+        method(renderer).call(content, type)
+      end
+    end
+
+  end
+end

data/lib/taverna_player/render_callbacks.rb

@@ -0,0 +1,41 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+def format_text_tp_default(content, type)
+  content = CodeRay.scan(content, :text).div(:css => :class)
+  auto_link(content, :html => { :target => '_blank' }, :sanitize => false)
+end
+
+def format_xml_tp_default(content, type)
+  out = String.new
+  REXML::Document.new(content).write(out, 1)
+  CodeRay.scan(out, :xml).div(:css => :class, :line_numbers => :table)
+end
+
+def show_image_tp_default(content, type)
+  # Can't use image_tag() here because the image doesn't really exist (it's in
+  # a zip file, really) and this confuses the Rails asset pipeline.
+  tag("img", :src => content)
+end
+
+def workflow_error_tp_default(content, type)
+  link_to("This output is a workflow error.", content)
+end
+
+def cannot_inline_tp_default(content, type)
+  "Sorry but we cannot show this type of content in the browser. Please " +
+   link_to("download it", content) + " to view it on your local machine."
+end
+
+def empty_tp_default(content, type)
+  "<div>&lt;empty output&gt;</div>"
+end

data/lib/taverna_player/version.rb

@@ -0,0 +1,15 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  VERSION = "0.1.0"
+end

data/lib/taverna_player/worker.rb

@@ -0,0 +1,325 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  class Worker
+
+    # How to get the interaction presentation frame out of the interaction page.
+    INTERACTION_REGEX = /document\.getElementById\(\'presentationFrame\'\)\.src = \"(.+)\";/
+
+    def initialize(run)
+      @run = run
+      @workflow = TavernaPlayer.workflow_proxy.class_name.find(@run.workflow_id)
+    end
+
+    # This tells delayed_job to only try and complete each run once.
+    def max_attempts
+      1
+    end
+
+    def perform
+      unless TavernaPlayer.pre_run_callback.nil?
+        status_message "Running pre-run tasks"
+        run_callback(TavernaPlayer.pre_run_callback, @run)
+      end
+
+      status_message "Connecting to Taverna Server"
+
+      server_uri = URI.parse(TavernaPlayer.server_address)
+      credentials = T2Server::HttpBasic.new(TavernaPlayer.server_username,
+        TavernaPlayer.server_password)
+      conn_params = TavernaPlayer.server_connection
+
+      begin
+        server = T2Server::Server.new(server_uri, conn_params)
+        wkf = File.read(TavernaPlayer.workflow_proxy.file(@workflow))
+
+        # Try and create the run bearing in mind that the server might be at
+        # the limit of runs that it can hold at once.
+        begin
+          run = server.create_run(wkf, credentials)
+        rescue T2Server::ServerAtCapacityError
+          status_message "Server full - please wait; run will start soon"
+
+          if cancelled?
+            cancel
+            return
+          end
+
+          sleep(TavernaPlayer.server_retry_interval)
+          retry
+        end
+
+        status_message "Initializing new workflow run"
+
+        @run.run_id = run.id
+        @run.state = run.status
+        @run.create_time = run.create_time
+        @run.save
+
+        unless @run.inputs.size == 0
+          status_message "Uploading run inputs"
+          @run.inputs.each do |input|
+            unless input.file.blank?
+              run.input_port(input.name).file = input.file.path
+            else
+              run.input_port(input.name).value = input.value
+            end
+          end
+        end
+
+        # Just add in all service credentials right now
+        TavernaPlayer::ServiceCredential.all.each do |cred|
+          run.add_password_credential(cred.uri, cred.login, cred.password)
+        end
+
+        status_message "Starting run"
+        run.name = @run.name
+
+        # Try and start the run bearing in mind that the server might be at
+        # the limit of runs that it can run at once.
+        while !run.start
+          status_message "Server busy - please wait; run will start soon"
+
+          if cancelled?
+            cancel(run)
+            return
+          end
+
+          sleep(TavernaPlayer.server_retry_interval)
+        end
+
+        @run.state = run.status
+        @run.start_time = run.start_time
+        @run.save
+
+        status_message "Running"
+        until run.finished?
+          sleep(TavernaPlayer.server_poll_interval)
+          waiting = false
+
+          if cancelled?
+            cancel(run)
+            return
+          end
+
+          run.notifications(:requests).each do |note|
+            if @run.has_parent?
+              next if note.has_reply?
+              int = Interaction.find_by_run_id_and_serial(@run.parent_id, note.serial)
+              new_int = Interaction.find_or_initialize_by_run_id_and_unique_id_and_serial(@run.id, note.id, note.serial)
+              if new_int.new_record?
+                note.reply(int.feed_reply, int.data)
+                new_int.displayed = true
+                new_int.replied = true
+                new_int.feed_reply = int.feed_reply
+                new_int.data = int.data
+                new_int.save
+              end
+            else
+              waiting = true unless note.has_reply?
+              int = Interaction.find_or_initialize_by_run_id_and_unique_id_and_serial(@run.id, note.id, note.serial)
+
+              # Need to catch this here in case some other process has replied.
+              if note.has_reply? && !int.replied?
+                int.replied = true
+                int.save
+              end
+
+              unless int.replied?
+                if int.page.blank?
+                  page = server.read(note.uri, "text/html", credentials)
+
+                  INTERACTION_REGEX.match(page) do
+                    page_uri = $1
+
+                    if page_uri.starts_with?(server.uri.to_s)
+                      page = server.read(URI.parse(page_uri), "text/html", credentials)
+                      int.page = page.gsub("#{run.interactions_uri.to_s}/pmrpc.js",
+                        "/assets/taverna_player/application.js")
+                    else
+                      int.page_uri = page_uri
+                    end
+                  end
+                end
+
+                if int.data.blank?
+                  int.data = note.input_data.force_encoding("UTF-8")
+                end
+
+                if !int.feed_reply.blank? && !int.data.blank?
+                  note.reply(int.feed_reply, int.data)
+
+                  int.replied = true
+                end
+
+                int.save
+              end
+            end
+          end
+
+          status_message(waiting ? "Waiting for user input" : "Running")
+        end
+
+        status_message "Gathering run outputs and log"
+        download_outputs(run)
+        download_log(run)
+
+        @run.outputs = process_outputs(run)
+        @run.finish_time = run.finish_time
+        @run.save
+
+        run.delete
+      rescue => exception
+        begin
+          unless run.nil?
+            download_log(run)
+            run.delete
+          end
+        rescue
+          # Try and grab the log then delete the run from Taverna Server here,
+          # but at this point we don't care if we fail...
+        end
+
+        unless TavernaPlayer.run_failed_callback.nil?
+          status_message "Running post-failure tasks"
+          run_callback(TavernaPlayer.run_failed_callback, @run)
+        end
+
+        backtrace = exception.backtrace.join("\n")
+        @run.failure_message = "#{exception.message}\n#{backtrace}"
+
+        @run.state = :failed
+        @run.finish_time = Time.now
+        status_message "Failed"
+        return
+      end
+
+      unless TavernaPlayer.post_run_callback.nil?
+        status_message "Running post-run tasks"
+        run_callback(TavernaPlayer.post_run_callback, @run)
+      end
+
+      @run.state = :finished
+      status_message "Finished"
+    end
+
+    private
+
+    def run_callback(callback, *params)
+      if callback.is_a? Proc
+        callback.call(*params)
+      else
+        method(callback).call(*params)
+      end
+    end
+
+    def download_log(run)
+      Dir.mktmpdir(run.id, Rails.root.join("tmp")) do |tmp_dir|
+        tmp_file_name = File.join(tmp_dir, "log.txt")
+        begin
+          run.log(tmp_file_name)
+          @run.log = File.new(tmp_file_name)
+          @run.save
+        rescue T2Server::AttributeNotFoundError
+          # We don't care if there's no log but we do want to catch the error!
+        end
+      end
+    end
+
+    def download_outputs(run)
+      Dir.mktmpdir(run.id, Rails.root.join("tmp")) do |tmp_dir|
+        tmp_file_name = File.join(tmp_dir, "all.zip")
+        run.zip_output(tmp_file_name)
+        @run.results = File.new(tmp_file_name)
+        @run.save
+      end
+    end
+
+    def process_outputs(run)
+      outputs = []
+
+      Dir.mktmpdir(run.id, Rails.root.join("tmp")) do |tmp_dir|
+        run.output_ports.each_value do |port|
+          output = TavernaPlayer::RunPort::Output.new(:name => port.name,
+            :depth => port.depth)
+
+          tmp_file_name = File.join(tmp_dir, port.name)
+
+          if port.depth == 0
+            Zip::ZipFile.open(@run.results.path) do |zip|
+             if port.type =~ /text/
+                output.value = zip.read(port.name)
+              else
+                port_name = port.error? ? "#{port.name}.error" : port.name
+                output.file = singleton_output(port_name, tmp_file_name, zip)
+              end
+            end
+          else
+            # TODO: Need to rework this so it's not just re-downloading the
+            # whole port again. This is the quickest way right now though.
+            port.zip("#{tmp_file_name}.zip")
+            output.file = File.new("#{tmp_file_name}.zip")
+          end
+
+          output.metadata = {
+            :size => port.size,
+            :type => port.type
+          }
+
+          outputs << output
+        end
+      end
+
+      outputs
+    end
+
+    def singleton_output(name, tmp_file, zip)
+      File.open(tmp_file, "wb") do |file|
+        file.write zip.read(name)
+      end
+
+      File.new(tmp_file)
+    end
+
+    def status_message(message)
+      @run.status_message = message
+      @run.save!
+    end
+
+    def cancelled?
+      # Need to poll for updates as the run instance may have been
+      # changed in the Rails app.
+      @run.reload
+      @run.stop
+    end
+
+    def cancel(run = nil)
+      status_message "Cancelling"
+
+      unless run.nil?
+        download_log(run)
+        run.delete
+      end
+
+      unless TavernaPlayer.run_cancelled_callback.nil?
+        status_message "Running post-cancel tasks"
+        run_callback(TavernaPlayer.run_cancelled_callback, @run)
+      end
+
+      @run.state = :cancelled
+      @run.finish_time = Time.now
+      status_message "Cancelled"
+    end
+
+  end
+end