taverna-player 0.1.0

data/lib/generators/templates/callbacks/render_callbacks.rb

@@ -0,0 +1,56 @@
+#------------------------------------------------------------------------------
+# 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
+#------------------------------------------------------------------------------
+
+# These methods are the default renderer callbacks that Taverna Player uses.
+# If you customize (or add to) the methods in this file you must register them
+# in the Taverna Player initializer. These methods will not override the
+# defaults automatically.
+#
+# Each method MUST accept two parameters:
+#  * The first (content) is what will be rendered. In the case of a text/*
+#    type output this will be the actual text. In the case of anything else
+#    this will be a path to the object to be linked to.
+#  * The second (type) is the MIME type of the output as a string. This allows
+#    a single method to handle multiple types or sub-types if needed.
+#
+# Note that you can use most of the ActiveView Helpers here as global methods
+# but the image_tag() method does not work as explained below.
+
+def format_text(content, type)
+  # Use CodeRay to format text so that newlines are respected.
+  content = CodeRay.scan(content, :text).div(:css => :class)
+
+  # Use auto_link to turn URI-like text into links.
+  auto_link(content, :html => { :target => '_blank' }, :sanitize => false)
+end
+
+def format_xml(content, type)
+  # Make sure XML is indented consistently.
+  out = String.new
+  REXML::Document.new(content).write(out, 1)
+  CodeRay.scan(out, :xml).div(:css => :class, :line_numbers => :table)
+end
+
+def show_image(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(content, type)
+  link_to("This output is a workflow error.", content)
+end
+
+def cannot_inline(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

data/lib/generators/templates/callbacks/worker_callbacks.rb

@@ -0,0 +1,31 @@
+#------------------------------------------------------------------------------
+# 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 player_pre_run_callback(run)
+  w = Workflow.find(run.workflow_id)
+  puts "Pre-run callback called for run '#{run.name}' of workflow '#{w.id}'"
+end
+
+def player_post_run_callback(run)
+  w = Workflow.find(run.workflow_id)
+  puts "Post-run callback called for run '#{run.name}' of workflow '#{w.id}'"
+end
+
+def player_run_cancelled_callback(run)
+  w = Workflow.find(run.workflow_id)
+  puts "Run-cancelled callback called for run '#{run.name}' of workflow '#{w.id}'"
+end
+
+def player_run_failed_callback(run)
+  w = Workflow.find(run.workflow_id)
+  puts "Run-failed callback called for run '#{run.name}' of workflow '#{w.id}'"
+end

data/lib/generators/templates/controllers/runs_controller.rb

@@ -0,0 +1,20 @@
+#------------------------------------------------------------------------------
+# 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 RunsController < TavernaPlayer::ApplicationController
+    # Do not remove the next line.
+    include TavernaPlayer::Concerns::Controllers::RunsController
+
+    # Extend the RunsController here.
+  end
+end

data/lib/generators/templates/controllers/service_credentials_controller.rb

@@ -0,0 +1,20 @@
+#------------------------------------------------------------------------------
+# 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 ServiceCredentialsController < TavernaPlayer::ApplicationController
+    # Do not remove the next line.
+    include TavernaPlayer::Concerns::Controllers::ServiceCredentialsController
+
+    # Extend the ServiceCredentialsController here.
+  end
+end

data/lib/generators/templates/initializer.rb

@@ -0,0 +1,154 @@
+# Taverna Player configuration
+
+TavernaPlayer.setup do |config|
+
+  # This should be set to the name of the workflow model class in the main
+  # application and the listed methods should also be mapped if necessary.
+  config.workflow_model_proxy("Workflow")
+  #config.workflow_model_proxy("Workflow") do |proxy|
+    # This is the method that returns the name of the workflow file. Your
+    # model MUST provide this otherwise a workflow cannot be run.
+    #proxy.file_method_name = :file
+
+    # This is the method that returns the title of the workflow. This can be
+    # left unset if your model does not have this field but if you want to
+    # set a run name at the time of run creation then you will need to
+    # provide one or override the new run view.
+    #proxy.title_method_name = :title
+
+    # This is a method that returns a list of descriptions of the workflow
+    # inputs. Each description should be of the form:
+    #  {
+    #    :name => "<input_name>",
+    #    :description => "<input_description>",
+    #    :example => "<input_example_value>"
+    #  }
+    #
+    # If you don't provide this method you will have to override the new run
+    # view to create and initialize the inputs to a workflow.
+    #proxy.inputs_method_name = :inputs
+  #end
+
+  # This should be set to the name of the user model class in the main
+  # application if you have one. This defaults to nil and should be left as
+  # such if your main application does not have users.
+  #config.user_model_proxy = "User"
+
+  # This should be set to the name of the method used to get the current user
+  # in the main app. For Devise this would be :current_user. Defaults to nil.
+  #config.current_user_callback = nil
+
+  # Taverna Server configuration information. The poll interval is in seconds
+  # and sets how often the server will be polled for updates by each worker.
+  # The retry interval is also in seconds and sets how long a worker will wait
+  # before trying to start a run if the server is initially busy.
+  config.server_address = "http://localhost:8080/taverna"
+  config.server_username = "taverna"
+  config.server_password = "taverna"
+  config.server_poll_interval = 5
+  config.server_retry_interval = 10
+
+  # Taverna Server connection configuration.
+  #config.server_connection[:verify_peer] = true
+  #config.server_connection[:ca_file] = "/etc/certs/my-cert.crt"
+  #config.server_connection[:ca_path] = "/etc/certs/"
+  #config.server_connection[:client_certificate] = "client-cert.crt"
+  #config.server_connection[:client_password] = "P@5$w0Rd!"
+  #config.server_connection[:ssl_version] = :TLSv1
+  #config.server_connection[:open_timeout] = 10
+  #config.server_connection[:read_timeout] = 10
+
+  # Where to store files created by workflow runs. Should be fully qualified
+  # or use :rails_root for the root directory of your application.
+  #config.file_store = ":rails_root/public/system"
+
+  # Callbacks to be run at various points during a workflow run. These can be
+  # defined as Proc objects or as methods and referenced by name.
+  #
+  # Be careful! If a callback fails then the worker running the job will fail!
+  #
+  # Add callbacks in this initializer or define them elsewhere and require the
+  # file as usual (if they are not pulled in by some other code). You can
+  # create example stub callbacks using:
+  #   "rails generate taverna_player:callbacks"
+  # which will put them in "lib/taverna_player_callbacks.rb".
+  #require "taverna_player_callbacks"
+
+  # The pre-run callback is called before the run has started (before Taverna
+  # Server is contacted, in fact).
+  # It takes the run model object as its parameter.
+  #config.pre_run_callback = Proc.new { |run| puts "Starting: #{run.name}" }
+  #config.pre_run_callback = "player_pre_run_callback"
+  #config.pre_run_callback = :player_pre_run_callback
+
+  # The post-run callback is called after the run has completed normally.
+  # It takes the run model object as its parameter.
+  #config.post_run_callback = Proc.new { |run| puts "Finished: #{run.name}" }
+  #config.post_run_callback = "player_post_run_callback"
+  #config.post_run_callback = :player_post_run_callback
+
+  # The run-cancelled callback is called if the run is cancelled by the user.
+  # It takes the run model object as its parameter.
+  #config.run_cancelled_callback = Proc.new { |run| puts "Cancelled: #{run.name}" }
+  #config.run_cancelled_callback = "player_run_cancelled_callback"
+  #config.run_cancelled_callback = :player_run_cancelled_callback
+
+  # The run-failed callback is called if the run fails for any reason.
+  # It takes the run model object as its parameter.
+  #config.run_failed_callback = Proc.new { |run| puts "Failed: #{run.name}" }
+  #config.run_failed_callback = "player_run_failed_callback"
+  #config.run_failed_callback = :player_run_failed_callback
+
+  # Callbacks to be run to render various types of workflow output. These can
+  # be defined as Proc objects or as methods and referenced by name.
+  #
+  # Be careful! If a callback fails then users will see an Internal Server
+  # Error (HTTP status code 500) instead of their run outputs!
+  #
+  # Add callbacks in this initializer or define them elsewhere and require the
+  # file as usual (if they are not pulled in by some other code). You can
+  # create example stub callbacks using:
+  #   "rails generate taverna_player:renderers"
+  # which will put them in "lib/taverna_player_renderers.rb".
+  #require "taverna_player_renderers"
+
+  # Renderers for each type of output (referenced by MIME type) must then be
+  # registered. All the renderers shown below are supplied as defaults.
+  #config.output_renderers do |renderers|
+    # Set a default renderer for if there is a workflow type that browsers
+    # can't otherwise handle.
+    #renderers.default(:cannot_inline)
+
+    # You can set a renderer to also be a default for the whole media-type. In
+    # this case the below renderer is to be used for ALL text/* types that
+    # aren't otherwise registered.
+    #renderers.add("text/plain", :format_text, true)
+
+    # This renderer overrides the default text/* renderer for text/xml outputs.
+    #renderers.add("text/xml", :format_xml)
+
+    # Browsers can't show all image types so just register very common ones.
+    #renderers.add("image/jpeg", :show_image)
+    #renderers.add("image/png", :show_image)
+    #renderers.add("image/gif", :show_image)
+    #renderers.add("image/bmp", :show_image)
+
+    # This is the workflow error type and you should have a special renderer
+    # for it.
+    #renderers.add("application/x-error", :workflow_error)
+  #end
+end
+
+# Example workflow run callbacks defined in the initializer.
+
+#def player_pre_run_callback(run)
+#  puts "Starting: #{run.name}"
+#end
+
+#def player_post_run_callback(run)
+#  puts "Finished: #{run.name}"
+#end
+
+#def player_run_cancelled_callback(run)
+#  puts "Cancelled: #{run.name}"
+#end

data/lib/generators/templates/models/run.rb

@@ -0,0 +1,20 @@
+#------------------------------------------------------------------------------
+# 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 Run < ActiveRecord::Base
+    # Do not remove the next line.
+    include TavernaPlayer::Concerns::Models::Run
+
+    # Extend the Run model here.
+  end
+end

data/lib/tasks/delete-cancelled-runs.rake

@@ -0,0 +1,26 @@
+#------------------------------------------------------------------------------
+# 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
+#------------------------------------------------------------------------------
+
+namespace :taverna_player do
+  desc "Delete all cancelled workflow runs."
+  task :delete_cancelled_runs => :environment do
+
+    gone = 0
+    TavernaPlayer::Run.all.each do |run|
+      if run.cancelled?
+        gone += 1 #if run.destroy
+      end
+    end
+
+    puts "#{gone} cancelled runs were deleted."
+  end
+end

data/lib/tasks/delete-old-embedded-runs.rake

@@ -0,0 +1,26 @@
+#------------------------------------------------------------------------------
+# 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
+#------------------------------------------------------------------------------
+
+namespace :taverna_player do
+  desc "Delete all completed embedded workflow runs."
+  task :delete_completed_embedded_runs => :environment do
+
+    gone = 0
+    TavernaPlayer::Run.find_all_by_embedded(true).each do |run|
+      if run.complete?
+        gone += 1 if run.destroy
+      end
+    end
+
+    puts "#{gone} complete embedded runs were deleted."
+  end
+end

data/lib/taverna-player.rb

@@ -0,0 +1,139 @@
+#------------------------------------------------------------------------------
+# 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
+#------------------------------------------------------------------------------
+
+require "require_all"
+require "coderay"
+require "delayed_job_active_record"
+require "jbuilder"
+require 'mime/types'
+require "paperclip"
+require "pmrpc-rails"
+require "rails_autolink"
+require "t2-server"
+require "taverna-t2flow"
+require "tmpdir"
+require "zip/zip"
+
+# Grab everything in the taverna_player directory using the require_all gem.
+require_rel "taverna_player"
+
+# This module serves as the configuration point of Taverna Player. Examples of
+# all configuration options can be found in the taverna_player initializer.
+module TavernaPlayer
+  # Configuration without defaults
+  mattr_accessor :server_address, :server_password, :server_username
+
+  # This should be set to the name of the workflow model class in the main
+  # application via the workflow_model_proxy method below.
+  mattr_reader :workflow_proxy
+
+  # :call-seq:
+  #   workflow_model_proxy(workflow_class) {|proxy| ...}
+  #
+  # Set up a proxy to the main application's workflow model. The class name
+  # should be supplied as a string, e.g. "Workflow".
+  #
+  # See the taverna_player initializer for more information.
+  def self.workflow_model_proxy(workflow_class)
+    @@workflow_proxy = ModelProxy.new(workflow_class, [:file, :title, :inputs])
+    yield @@workflow_proxy if block_given?
+  end
+
+  # This should be set to the name of the user model class in the main
+  # application via the user_model_proxy method below. Defaults to nil.
+  mattr_reader :user_proxy
+  @@user_proxy = nil
+
+  # :call-seq:
+  #   user_model_proxy = user_class
+  #
+  # Set up a proxy to the main application's user model if it has one. The
+  # class name should be supplied as a string, e.g. "User".
+  #
+  # See the taverna_player initializer for more information.
+  def self.user_model_proxy=(user_class)
+    @@user_proxy = ModelProxy.new(user_class)
+  end
+
+  # This should be set to the name of the method used to get the current user
+  # in the main app. For Devise this would be :current_user. Defaults to nil.
+  mattr_accessor :current_user_callback
+  @@current_user_callback = nil
+
+  # Setup default output render callbacks.
+  mattr_reader :output_renderer
+  @@output_renderer = OutputRenderer.new
+  @@output_renderer.default(:cannot_inline_tp_default)
+  @@output_renderer.add("text/plain", :format_text_tp_default, true)
+  @@output_renderer.add("text/xml", :format_xml_tp_default)
+  @@output_renderer.add("image/jpeg", :show_image_tp_default)
+  @@output_renderer.add("image/png", :show_image_tp_default)
+  @@output_renderer.add("image/gif", :show_image_tp_default)
+  @@output_renderer.add("image/bmp", :show_image_tp_default)
+  @@output_renderer.add("application/x-error", :workflow_error_tp_default)
+  @@output_renderer.add("application/x-empty", :empty_tp_default)
+  @@output_renderer.add("inode/x-empty", :empty_tp_default)
+
+  # :call-seq:
+  #   output_renderers {|renderer| ...}
+  #
+  # Set up the renderers for each MIME type that you want to be able to show
+  # in the browser. In most cases the supplied defaults will be sufficient.
+  #
+  # See the taverna_player initializer for more information.
+  def self.output_renderers
+    yield @@output_renderer if block_given?
+  end
+
+  # Path to place where files should be stored.
+  mattr_accessor :file_store
+  @@file_store = ":rails_root/public/system"
+
+  # Taverna server polling interval (in seconds)
+  mattr_accessor :server_poll_interval
+  @@server_poll_interval = 5
+
+  # Taverna server retry interval (in seconds)
+  mattr_accessor :server_retry_interval
+  @@server_retry_interval = 10
+
+  # Taverna Server connection parameters
+  mattr_accessor :server_connection
+  @@server_connection = T2Server::DefaultConnectionParameters.new
+
+  # Pre run callback
+  mattr_accessor :pre_run_callback
+  @@pre_run_callback = nil
+
+  # Post run callback
+  mattr_accessor :post_run_callback
+  @@post_run_callback = nil
+
+  # Run cancelled callback
+  mattr_accessor :run_cancelled_callback
+  @@run_cancelled_callback = nil
+
+  # Run failed callback
+  mattr_accessor :run_failed_callback
+  @@run_failed_callback = nil
+
+  # :call-seq:
+  #   setup {|config| ...}
+  #
+  # Yield this configuration class so that Taverna Player can be set up.
+  #
+  # See the taverna_player initializer for more information.
+  def self.setup
+    yield self
+  end
+
+end