taverna-player 0.1.0

data/lib/taverna_player/concerns/controllers/runs_controller.rb

@@ -0,0 +1,281 @@
+#------------------------------------------------------------------------------
+# 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
+  module Concerns
+    module Controllers
+      module RunsController
+
+        extend ActiveSupport::Concern
+
+        included do
+          respond_to :html, :json, :js
+
+          before_filter :find_runs, :only => [ :index ]
+          before_filter :find_run, :except => [ :index, :new, :create ]
+          before_filter :find_workflow, :only => [ :new ]
+          before_filter :setup_new_run, :only => :new
+          before_filter :set_run_user, :only => :create
+          before_filter :filter_update_parameters, :only => :update
+          before_filter :find_interaction, :only => [ :read_interaction, :write_interaction ]
+
+          layout :choose_layout
+
+          private
+
+          def find_runs
+            select = { :embedded => false }
+            select[:workflow_id] = params[:workflow_id] if params[:workflow_id]
+            @runs = Run.where(select).all
+          end
+
+          def find_run
+            @run = Run.find(params[:id])
+          end
+
+          def find_workflow
+            @workflow = TavernaPlayer.workflow_proxy.class_name.find(params[:workflow_id])
+          end
+
+          def setup_new_run
+            @run = Run.new(:workflow_id => @workflow.id)
+            @run.embedded = true if params[:embedded] == "true"
+          end
+
+          def set_run_user
+            return if params[:run][:embedded] == "true" || TavernaPlayer.user_proxy.nil?
+
+            unless TavernaPlayer.current_user_callback.blank?
+              user = method(TavernaPlayer.current_user_callback).call
+              params[:run][:user_id] = user.id unless user.nil?
+            end
+          end
+
+          def filter_update_parameters
+            name = params[:run][:name]
+            @update_parameters = { :name => name } unless name.blank?
+          end
+
+          def find_interaction
+            @interaction = Interaction.find_by_unique_id(params[:int_id])
+          end
+
+          # Read the data from the results zip file.
+          def read_from_zip(file)
+            Zip::ZipFile.open(@run.results.path) do |zip|
+              zip.read(file)
+            end
+          end
+
+          # This is here because of Taverna's infinitely deep output ports :-(
+          def recurse_into_lists(list, indexes)
+            return list if indexes.empty? || !list.is_a?(Array)
+            i = indexes.shift
+            return recurse_into_lists(list[i], indexes)
+          end
+
+          # Choose a layout for the page depending on action and embedded status.
+          def choose_layout
+            if (action_name == "new" || action_name == "show") && @run.embedded?
+              "taverna_player/embedded"
+            else
+              ApplicationController.new.send(:_layout).virtual_path
+            end
+          end
+
+        end # included
+
+        # GET /runs
+        def index
+
+        end
+
+        # GET /runs/1
+        def show
+          if @run.running?
+            @interaction = Interaction.find_by_run_id_and_replied(@run.id, false)
+            unless @interaction.nil?
+              unless @interaction.displayed
+                @new_interaction = true
+                @interaction.displayed = true
+                @interaction.save
+              end
+            end
+          end
+
+          respond_with(@run) do |format|
+            # Render show.{html|js}.erb unless the run is embedded.
+            format.any(:html, :js) do
+              render "taverna_player/runs/embedded/show" if @run.embedded
+            end
+          end
+        end
+
+        # GET /runs/new
+        def new
+          respond_with(@run) do |format|
+            # Render new.html.erb unless the run is embedded.
+            format.html do
+              render "taverna_player/runs/embedded/new" if @run.embedded
+            end
+          end
+        end
+
+        # POST /runs
+        def create
+          @run = Run.new(params[:run])
+          if @run.save
+            flash[:notice] = "Run was successfully created."
+          end
+
+          respond_with(@run, :status => :created, :location => @run)
+        end
+
+        # PUT /runs/1
+        def update
+          @run.update_attributes(@update_parameters)
+
+          respond_with(@run)
+        end
+
+        # DELETE /runs/1
+        def destroy
+          if @run.destroy
+            flash[:notice] = "Run was deleted."
+            respond_with(@run)
+          else
+            flash[:error] = "Run must be cancelled before deletion."
+            respond_with(@run, :nothing => true, :status => :forbidden) do |format|
+              format.html { redirect_to :back }
+            end
+          end
+        end
+
+        # PUT /runs/1/cancel
+        def cancel
+          @run.cancel unless @run.complete?
+
+          respond_with(@run, :action => :show) do |format|
+            format.html do
+              if @run.embedded?
+                redirect_to view_context.new_embedded_run_path(@run)
+              else
+                redirect_to :back
+              end
+            end
+          end
+        end
+
+        # GET /runs/1/download/log
+        def download_log
+          send_file @run.log.path, :type => "text/plain",
+            :filename => "#{@run.name}-log.txt"
+        end
+
+        # GET /runs/1/download/results
+        def download_results
+          send_file @run.results.path, :type => "application/zip",
+            :filename => "#{@run.name}-all-results.zip"
+        end
+
+        # GET /runs/1/download/output/:port
+        def download_output
+          output = RunPort::Output.find_by_run_id_and_name(@run.id, params[:port])
+
+          # If there is no such output port then return a 404.
+          raise ActionController::RoutingError.new('Not Found') if output.nil?
+
+          if output.file.blank?
+            send_data output.value, :type => "text/plain",
+              :filename => "#{@run.name}-#{output.name}.txt"
+          else
+            send_file output.file.path, :type => output.file.content_type,
+              :filename => "#{@run.name}-#{output.file_file_name}"
+          end
+        end
+
+        # GET /runs/1/input/*
+        def input
+          input = RunPort::Input.find_by_run_id_and_name(@run.id, params[:port])
+
+          # If there is no such input port then return a 404.
+          raise ActionController::RoutingError.new('Not Found') if input.nil?
+
+          if input.file.blank?
+            send_data input.value, :disposition => "inline"
+          else
+            send_file input.file.path, :disposition => "inline"
+          end
+        end
+
+        # GET /runs/1/output/*
+        def output
+          # We need to parse out the path into a list of numbers here so we have
+          # a list of indices into the file structure.
+          path = []
+          unless params[:path].nil?
+            path = params[:path].split("/").map { |p| p.to_i }
+          end
+
+          output = RunPort::Output.find_by_run_id_and_name(@run.id, params[:port])
+
+          # If there is no such output port or the path is the wrong depth then
+          # return a 404.
+          if output.nil? || path.length != output.depth
+            raise ActionController::RoutingError.new('Not Found')
+          end
+
+          # A singleton should just return the value (if it's small enough) or the
+          # file if it's bigger. If it's a value in the database then it'll always
+          # be a text value, although not necessarily "plain".
+          if output.depth == 0 && !output.value.blank?
+            send_data output.value, :disposition => "inline",
+              :type => output.metadata[:type]
+          else
+          # We need to rebuild the path indices into a string here (and can't
+          # re-use the params[:path] variable directly) because files are
+          # indexed from one in the zip we get back from Server, not zero.
+            path_s = path.map { |p| p += 1 }.join("/")
+            file = path_s.blank? ? "#{output.name}" : "#{output.name}/#{path_s}"
+            type = recurse_into_lists(output.metadata[:type], path)
+
+            # If it's an error, then we need to further hack the file path and
+            # content type.
+            if type == "application/x-error"
+              file += ".error"
+              type = "text/plain"
+            end
+
+            send_data read_from_zip(file), :type => type,
+              :disposition => "inline"
+          end
+        end
+
+        # GET /runs/1/interaction/:int_id
+        def read_interaction
+          send_data @interaction.page, :type => "text/html",
+            :disposition => "inline"
+        end
+
+        # POST /runs/1/interaction/:int_id
+        def write_interaction
+          @interaction.data = request.body.read
+          @interaction.feed_reply = request.headers["X-Taverna-Interaction-Reply"]
+          @interaction.save
+
+          render :nothing => true, :status => 201
+        end
+
+      end
+    end
+  end
+end

data/lib/taverna_player/concerns/controllers/service_credentials_controller.rb

@@ -0,0 +1,89 @@
+#------------------------------------------------------------------------------
+# 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
+  module Concerns
+    module Controllers
+      module ServiceCredentialsController
+
+        extend ActiveSupport::Concern
+
+        included do
+          respond_to :html
+
+          before_filter :find_creds, :only => [ :index ]
+          before_filter :find_cred, :except => [ :index, :new, :create ]
+
+          private
+
+          def find_creds
+            @service_credentials = ServiceCredential.all
+          end
+
+          def find_cred
+            @service_credential = ServiceCredential.find(params[:id])
+          end
+        end
+
+        # GET /service_credentials
+        def index
+
+        end
+
+        # GET /service_credentials/1
+        def show
+
+        end
+
+        # GET /service_credentials/new
+        def new
+          @service_credential = ServiceCredential.new
+        end
+
+        # GET /service_credentials/1/edit
+        def edit
+
+        end
+
+        # POST /service_credentials
+        def create
+          @service_credential = ServiceCredential.new(params[:service_credential])
+
+          if @service_credential.save
+            flash[:notice] = "Service credential was successfully created."
+          end
+
+          respond_with(@service_credential)
+        end
+
+        # PUT /service_credentials/1
+        def update
+          if @service_credential.update_attributes(params[:service_credential])
+            flash[:notice] = "Service credential was successfully updated."
+          end
+
+          respond_with(@service_credential)
+        end
+
+        # DELETE /service_credentials/1
+        def destroy
+          if @service_credential.destroy
+            flash[:notice] = "Service credential was deleted."
+          end
+
+          respond_with(@service_credential)
+        end
+
+      end
+    end
+  end
+end

data/lib/taverna_player/concerns/models/run.rb

@@ -0,0 +1,205 @@
+#------------------------------------------------------------------------------
+# 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
+  module Concerns
+    module Models
+      module Run
+
+        extend ActiveSupport::Concern
+
+        included do
+          attr_accessible :create_time, :delayed_job, :embedded, :finish_time,
+            :inputs_attributes, :log, :name, :parent_id, :results, :run_id,
+            :start_time, :status_message, :user_id, :workflow_id
+
+          # Each run is spawned from a workflow. This provides the link to the
+          # workflow model in the parent app, whatever it calls its model.
+          belongs_to :workflow, :class_name => TavernaPlayer.workflow_proxy.class_name.to_s
+
+          unless TavernaPlayer.user_proxy.nil?
+            belongs_to :user, :class_name => TavernaPlayer.user_proxy.class_name.to_s
+          end
+
+          has_many :inputs, :class_name => "TavernaPlayer::RunPort::Input",
+            :dependent => :destroy
+          has_many :outputs, :class_name => "TavernaPlayer::RunPort::Output",
+            :dependent => :destroy
+          has_many :interactions, :class_name => "TavernaPlayer::Interaction",
+            :dependent => :destroy
+          belongs_to :delayed_job, :class_name => "::Delayed::Job"
+
+          # A run can have children, which are runs.
+          # A run can have a parent, which is another run.
+          has_many :children, :class_name => "TavernaPlayer::Run",
+            :foreign_key => "parent_id", :dependent => :nullify
+          belongs_to :parent, :class_name => "TavernaPlayer::Run"
+
+          accepts_nested_attributes_for :inputs
+
+          STATES = ["pending", "initialized", "running", "finished", "cancelled", "failed"]
+
+          validates :workflow_id, :presence => true
+          validates :name, :presence => true
+
+          # There is a :cancelled state but it can only be set if the run has
+          # previously had its stop flag set. This is to avoid race conditions.
+          # If we used a state to tell the delayed job worker to cancel a run
+          # it could be overwritten when the worker itself moves the run
+          # between states, thus losing the cancel request from the user.
+          validates :saved_state, :inclusion => { :in => STATES }
+          validates :stop, :presence => true, :if => :cancelled?
+
+          # A parent must have an "older" run id than its children. This only
+          # needs to be checked on update because on create we don't have an
+          # id for ourself.
+          validates :parent_id, :numericality => { :less_than => :id,
+              :message => "Parents must have lower ids than children" },
+            :allow_nil => true, :on => :update
+
+          has_attached_file :log,
+            :path => File.join(TavernaPlayer.file_store, ":class/:attachment/:id/:filename"),
+            :url => "/runs/:id/download/log",
+            :default_url => ""
+
+          has_attached_file :results,
+            :path => File.join(TavernaPlayer.file_store, ":class/:attachment/:id/:filename"),
+            :url => "/runs/:id/download/results",
+            :default_url => ""
+
+          after_initialize :initialize_child_run, :if => "new_record? && has_parent?"
+          after_create :populate_child_inputs, :if => :has_parent?
+          after_create :enqueue
+          before_destroy :complete?
+
+          private
+
+          # A child run MUST have the same workflow as its parent.
+          def initialize_child_run
+            self.workflow = parent.workflow
+          end
+
+          # For each input on the parent run, make sure we have an equivalent
+          # on the child. Copy the values/files of inputs that are missing.
+          def populate_child_inputs
+            parent.inputs.each do |i|
+              input = TavernaPlayer::RunPort::Input.find_or_initialize_by_run_id_and_name(id, i.name)
+              if input.new_record?
+                input.value = i.value
+                input.file = i.file
+                input.depth = i.depth
+                input.save
+              end
+            end
+          end
+
+          def enqueue
+            worker = TavernaPlayer::Worker.new(self)
+            job = Delayed::Job.enqueue worker, :queue => "player"
+            update_attributes(:delayed_job => job, :status_message => "Queued")
+          end
+
+        end # included
+
+        # Get the original ancestor of this run. In practice this is the first
+        # run in the chain without a parent.
+        def root_ancestor
+          has_parent? ? parent.root_ancestor : self
+        end
+
+        # There are two courses of action here:
+        #
+        # * If the run is already running then cancel this run by setting the
+        #   stop flag. This is done to allow the delayed job that is
+        #   monitoring the run to delete it and clean up Taverna Server
+        #   gracefully.
+        # * If the run is still in the queue, destroy the queue object. This
+        #   is checked in a transaction so that we don't get hit with a race
+        #   condition between checking the queued status of the run and
+        #   actually removing it from the queue.
+        #
+        # In both cases the stop flag is set to mark the run as cancelled
+        # internally.
+        #
+        # See the note above about the :cancelled state.
+        def cancel
+          return if complete?
+
+          # If the run has a delayed job (still) and it hasn't been locked yet
+          # then we just remove it from the queue directly and mark the run as
+          # cancelled.
+          unless delayed_job.nil?
+            delayed_job.with_lock do
+              if delayed_job.locked_by.nil?
+                delayed_job.destroy
+                update_attribute(:saved_state, "cancelled")
+                update_attribute(:status_message, "Cancelled")
+              end
+            end
+          end
+
+          update_attribute(:stop, true)
+        end
+
+        # Return state as a symbol. If a run is running, but has been asked to
+        # stop, then it is :cancelling. This is a pseudo-state to avoid race
+        # conditions when cancelling a run so is specifically NOT in the list
+        # of allowed states above.
+        def state
+          s = self[:saved_state].to_sym
+          if s == :running
+            stop ? :cancelling : :running
+          else
+            s
+          end
+        end
+
+        # Save state as a downcased string. See the note above about why a
+        # state cannot be used to actually cancel a run.
+        def state=(state)
+          s = state.to_s.downcase
+          return if s == "cancelled" && !stop
+          self[:saved_state] = s
+        end
+
+        def running?
+          state == :running
+        end
+
+        def finished?
+          state == :finished
+        end
+
+        def cancelled?
+          state == :cancelled
+        end
+
+        def cancelling?
+          state == :cancelling
+        end
+
+        def failed?
+          state == :failed
+        end
+
+        # This is used as a catch-all for finished, cancelled and failed
+        def complete?
+          finished? || cancelled? || failed?
+        end
+
+        def has_parent?
+          !parent_id.nil?
+        end
+      end
+    end
+  end
+end