umlaut 3.0.0alpha1

data/app/helpers/search_helper.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+module SearchHelper
+
+  def search_result_target_window
+    umlaut_config.lookup!("search.result_link_target","")
+  end
+
+  # pass in an openurl context obj.
+  # return an OpenStruct with atitle_label, title_label
+  def referent_labels(context_obj = @current_context_object)
+    ref_meta = context_obj.referent.metadata
+    
+    result = OpenStruct.new
+    
+    if ref_meta['genre'].blank?
+      case @current_context_object.referent.format 
+      when  'book'
+        result.atitle = 'Chapter/Part Title'
+      when @current_context_object.referent.format == 'journal'
+        result.atitle = 'Article Title'
+      end
+      result.title = 'Title'      
+    else
+      case ref_meta["genre"]
+      when /article|journal|issue/
+        result.atitle = 'Article Title'
+        result.title = 'Journal Title'
+      when /bookitem|book/
+        result.atitle = 'Chapter/Part Title'
+        result.title = 'Book Title'
+      when /proceeding|conference/
+        result.atitle = 'Proceeding Title'
+        result.title = 'Conference Name'
+      when 'report'
+        result.atitle = 'Report Title'
+        result.title = 'Report'
+      end
+    end
+
+    return result    
+  end
+  
+  # A-Z buttons in search page
+  def group_list
+    group_list ||= ('A'..'Z').to_a.push('0-9').push('Other')  
+  end
+  
+
+end

data/app/helpers/umlaut/footer_helper.rb

@@ -0,0 +1,64 @@
+# Some rails view helpers useful for debugging links, and rendering credits
+# in footer. 
+module Umlaut::FooterHelper
+  
+  # Renders list of external services used by currently configured Umlaut, 
+  # with URLs. In some cases ToS of third party services may require this.
+  # Gets list from "credits" config in Service plugins. 
+  # Requires @collection ivar in controller holding an umlaut Collection
+  # object, as there will be in ResolveController. 
+  def render_service_credits
+    if @collection
+      content = "".html_safe
+            
+      content << "Powered by ".html_safe + link_to("Umlaut", "http://github.com/team_umlaut/umlaut") + ". ".html_safe
+      
+      credit_segments = []
+      
+      services = @collection.instantiate_services!
+      
+      # put em all in one hash to eliminate exact-name dups
+      credits = {}
+      services.each {|s|  credits.merge! s.credits } 
+      
+      credits.keys.sort.each do |name|
+        if credits[name].blank?
+          credit_segments << html_escape(name)
+        else
+          credit_segments << link_to(name, credits[name])
+        end
+      end
+      
+      
+      if credit_segments.length > 0
+        content << "Using services from ".html_safe
+        content << credit_segments.join(", ").html_safe
+        content << " and others.".html_safe
+      end
+      
+      return content
+    end
+  end
+  
+  # tiny [S] link directly to SFX, in footer. For debugging.
+  # Only if sfx.sfx_base_url is configured. 
+  def link_to_direct_sfx
+    if (base = umlaut_config.lookup!("sfx.sfx_base_url")) && @user_request
+      url = base.chomp("?") + "?"
+      url += @user_request.to_context_object.kev
+      url += "&sfx.ignore_date_threshold=1" if respond_to?(:title_level_request) && title_level_request?
+      
+      link_to "[S]", url
+    end
+  end
+  
+  # If you have a config.test_resolve_base configured,
+  # will output a [T] link, usually for footer, for staff
+  # debugging. 
+  def link_to_test_resolve
+    if (test_base = umlaut_config.lookup!("test_resolve_base")) && @user_request
+      link_to "[T]", test_base.chomp("?") + "?" + @user_request.to_context_object.kev
+    end
+  end
+
+end

data/app/helpers/umlaut/helper.rb

@@ -0,0 +1,62 @@
+# Rails view helpers needed accross Umlaut controllers are collected
+# here. Generally UmlautController will call "helper Umlaut::Helper" to
+# expose these to all umlaut controllers. 
+
+module Umlaut::Helper
+  include Umlaut::UrlGeneration
+  include Umlaut::FooterHelper
+  include Umlaut::HtmlHeadHelper
+  
+  
+  
+  # pass in an OpenURL::ContextObject, outputs a link.
+  def resolver_link(context_object, params={})
+    
+    # Content of the link. 
+    if ( umlaut_config.link_img_url && params[:text].blank? )
+      link_content = image_tag(umlaut_config.link_img_url, :border=>0, :alt=>umlaut_config.app_name)
+    elsif ! params[:text].blank?
+      link_content = params[:text]
+    else
+      link_content = umlaut_config.app_name
+    end
+
+    # url of the link. 
+    if ( params[:params])
+      link_to_arg = params[:params]
+    else
+      link_params = {:controller=>'resolve'}
+      link_params.merge!( params[:extra_params] ) if params[:extra_params]
+      link_to_arg = url_for_with_co( link_params, context_object )      
+    end
+    
+    link_to(link_content, link_to_arg , :target=>params[:target])
+  end
+
+  # formats dates sent in an OpenURL into a more human-friendly
+  # format. Input Dates look like '20000304'. Can be just year, or just
+  # year/month, or all. Not sure what this format
+  # is officially called. Not sure if they can have dashes sometimes? 
+  def date_format(date_string)      
+    date_string =~ /(\d\d\d\d)\-?(\d\d)?\-?(\d\d)?/
+
+    begin
+      year, month, day_of_month = $1, $2, $3
+  
+      if ( month )                
+        date = Date.civil(year.to_i, month.to_i)
+        formatted_month = date.strftime('%b')
+      end
+      
+      output = year
+      output += ' ' + formatted_month if formatted_month
+      output += ' ' + day_of_month if day_of_month && day_of_month.to_i != 0
+  
+      return output
+    rescue
+      return date_string
+    end
+  end
+
+  
+end

data/app/helpers/umlaut/html_head_helper.rb

@@ -0,0 +1,37 @@
+# Rails view helpers for outputting standard Umlaut content included
+# in html <head>. Generally a layout will call #render_umlaut_head_content
+# to render all standard Umlaut <head> content in a future-compatible way. 
+module Umlaut::HtmlHeadHelper
+  
+  # usually called in layout, render a link tag with opensearch auto-discovery
+  def render_opensearch_link
+    tag("link", 
+        :rel => "search", 
+        :type => "application/opensearchdescription+xml", 
+        :title =>  umlaut_config.opensearch_short_name,
+        :href => url_for(:controller=>'open_search', :only_path=>false)
+        )
+  end
+  
+  # used on non-js progress page, we need to refresh the page
+  # if requested by presence of @meta_refresh_self ivar. 
+  # this method usually called in a layout. 
+  def render_meta_refresh
+     if @meta_refresh_self    
+      tag( "meta",
+        "http-equiv" => "refresh",
+        "content" => @meta_refresh_self
+        )
+      else
+        ""
+      end
+  end
+  
+  # standard umlaut head content, may later include more
+  # stuff, local/custom layouts should call this in HEAD
+  # to get forwards-compatible umlaut standard head content
+  def render_umlaut_head_content
+    render_opensearch_link + render_meta_refresh
+  end
+  
+end

data/app/helpers/umlaut/url_generation.rb

@@ -0,0 +1,77 @@
+# A Rails view helper module, which over-rides #url_for and some other
+# rails url-generating methods, so that they can be forced to generate
+# absolute URLs if a controller iVar is set to say so. 
+#
+# This is used by our partial HTML api responses, so make sure html snippets
+# have absolute URLs in them. 
+
+module Umlaut::UrlGeneration
+  
+  # Over-ride to allow default forcing of urls with hostnames.
+  # This is neccesary for our partial_html_sections service
+  # to work properly. Just set @generate_url_with_host = true
+  # in your controller, and urls will be generated with hostnames
+  # for the remainder of that action. 
+  def url_for(argument = {})    
+    if @generate_urls_with_host
+      case argument
+      when Hash
+        # Force only_path = false if not already set
+        argument[:only_path] = false if argument[:only_path].nil?
+        return super(argument)
+      when String
+        # We already have a straight string, if it looks relative, 
+        # absolutize it. 
+        if argument.starts_with?("/")
+          return root_url.chomp("/") + argument
+        else
+          return super(argument)
+        end
+      when :back
+        return super(argument)
+      else 
+        # polymorphic, we want to force polymorphic_url instead
+        # of default polymorphic_path         
+        return polymorphic_url(argument)
+      end    
+    else
+      # @generate_urls_with_host not set, just super
+      super(argument)
+    end    
+  end
+
+  # over-ride path_to_image to generate complete urls with hostname and everything
+  # if @generate_url_with_host is set. This makes image_tag generate
+  # src with full url with host. See #url_for
+  def path_to_image(source)
+    path = super(source)
+    if @generate_urls_with_host
+      protocol =  request.protocol()
+      path = protocol + request.host_with_port() + path
+    end
+    return path
+  end
+  # Rails2 uses 'path_to_image' instead, that's what we have to override,
+  # we used to use image_path, so let's alias that too. 
+  alias :image_path :path_to_image
+
+  
+  # We want stylesheets and javascripts to do the exact same thing,
+  # magic of polymorphous super() makes it work:
+  def path_to_stylesheet(source)
+    path = super
+    if @generate_urls_with_host    
+      path = request.protocol() + request.host_with_port() + path
+    end
+    return path
+  end
+
+  def path_to_javascript(source)
+    path = super
+    if @generate_urls_with_host    
+      path = request.protocol() + request.host_with_port() + path
+    end
+    return path
+  end  
+
+end

data/app/mailers/emailer.rb

@@ -0,0 +1,48 @@
+class Emailer < ActionMailer::Base
+  include UmlautConfigurable
+    
+  self.umlaut_config = UmlautController.umlaut_config
+  
+  helper :application
+
+  
+  def citation(recipient, user_request, fulltexts, holdings)
+    @title  = find_good_title(user_request.referent)
+    @fulltexts  = fulltexts
+    @holdings  = holdings
+    @user_request = user_request
+    
+    mail(:to => recipient, 
+         :from => umlaut_config.from_email_addr, 
+         :'Reply-to' => umlaut_config.from_email_addr,
+         :subject => "#{umlaut_config.app_name} result: #{find_good_title(user_request.referent)}")
+  end
+  
+  def short_citation(recipient, user_request, location, call_number)
+    
+ 
+    @title  = find_good_title(user_request.referent)
+    @location  = location
+    @call_number  = call_number
+    @user_request = user_request
+    
+    mail(:to => recipient, 
+         :from => umlaut_config.from_email_addr,
+         :'Reply-to' => umlaut_config.from_email_addr, 
+         :subject => "#{umlaut_config.app_name} result")
+
+  end
+
+  protected
+    def find_good_title(referent)
+      citation = referent.to_citation
+      if citation[:container_title]
+        return citation[:container_title]
+      else
+        return "#{citation[:title]} / #{citation[:author]}" 
+      end      
+    end
+
+
+  
+end

data/app/models/clickthrough.rb

@@ -0,0 +1,2 @@
+class Clickthrough < ActiveRecord::Base
+end

data/app/models/collection.rb

@@ -0,0 +1,259 @@
+require 'CronTab' # for understanding CronTab format for expiring responses. 
+
+# A Collection object encapsulates a given UmlautRequest, and a given
+# list of Umlaut services that should be run off that request.
+#
+# That's exactly what it's initialized with: an umlaut request, and
+# list of service definitions. Third parameter pass in an umlaut configuration
+# object, to get various timeout values. If you don't pass one in, defaults
+# will be used. 
+#
+# The Collection holds and executes the logic for running those services, 
+# foreground and background, making sure no service is run twice if it's
+# already in progress, timing out expired services, etc. 
+class Collection
+  
+  attr_accessor :umlaut_request
+  attr_accessor :logger
+  # configs
+  attr_accessor :response_expire_interval, :response_expire_crontab_format, :background_service_timeout, :requeue_failedtemporary_services
+  
+   
+  def initialize(a_umlaut_request, service_hash, config = Confstruct::Configuration.new)    
+    self.umlaut_request = a_umlaut_request
+    
+    self.logger = Rails.logger
+    
+    self.response_expire_interval = config.lookup!("response_expire_interval", 1.day)
+    self.response_expire_crontab_format = config.lookup!("response_expire_crontab_format", nil)
+    self.background_service_timeout =  config.lookup!("background_service_timeout", 30.seconds)
+    self.requeue_failedtemporary_services = config.lookup!("requeue_failedtemporary_services", 500.seconds)
+        
+    # @service_definitions will be a two-level hash, pointing to an array.. Task is Standard, LinkOut, etc.
+    # { [task] => { [priority_level] => [config1, config2, config3],
+    #                [priority_level_2] => [configa], }
+    #     [...]
+    # }
+    @service_definitions_flat = service_hash
+    @service_definitions = {}
+
+    # Arrange services by type and priority in @service_definitions     
+    gather_services
+  end
+
+  # Starts running all services that are in this collection, for the given
+  # request set for this collection, if and only if they are not already
+  # in progress.
+  #
+  # This method can be run on a request multiple times, it'll only re-execute
+  # services that are executable (not already running, or timed out). 
+  # That characteristic is used when this method is called on a page refresh
+  # or background update status check.   
+  #
+  # Sets all services in collection to have a 'queued' status if appropriate.
+  # Then actually executes the services that are dispatchable (queued).    
+  def dispatch_services!
+    # Go through currently dispatched services, looking for timed out
+    # services -- services still in progress that have taken too long,
+    # as well as service responses that are too old to be used.      
+    umlaut_request.dispatched_services.each do | ds |
+        # go through dispatched_services and set stil in progress but too long to failed temporary
+        if ( (ds.status == DispatchedService::InProgress ||
+              ds.status == DispatchedService::Queued ) &&
+              (Time.now - ds.updated_at) > self.background_service_timeout)
+
+              ds.store_exception( Exception.new("background service timed out (took longer than #{self.background_service_timeout} to run); thread assumed dead.")) unless ds.exception_info
+              # Fail it temporary, it'll be run again. 
+              ds.status = DispatchedService::FailedTemporary
+              ds.save!
+              logger.warn("Background service timed out, thread assumed dead. #{umlaut_request.id} / #{ds.service_id}")
+         end
+         
+        # go through dispatched_services and delete:
+        # 1) old completed dispatches, too old to use. 
+        # 2) failedtemporary dispatches that are older than our resurrection time
+        # -> And all responses associated with those dispatches. 
+        # After being deleted, they'll end up re-queued. 
+        if ( (ds.completed? && completed_dispatch_expired?(ds) ) ||
+             (  ds.status == DispatchedService::FailedTemporary &&
+               (Time.now - ds.updated_at) > self.requeue_failedtemporary_services 
+              )
+            )
+            
+          # Need to expire. Delete all the service responses, and
+          # the DispatchedService record, and service will be automatically
+          # run again.
+          serv_id = ds.service_id
+          
+          umlaut_request.service_responses.each do |response|            
+            if response.service_id == serv_id
+              umlaut_request.service_responses.delete(response)              
+              response.destroy
+            end
+          end
+          
+          umlaut_request.dispatched_services.delete(ds)
+          ds.destroy
+        end
+    end
+        
+    # Queue any services without a dispatch marker at all, keeping
+    # track of queued services, already existing or newly created. 
+    
+    # Just in case, we're going to refetch dispatched_services from the db,
+    # in case some other http request or background service updated things
+    # recently. 
+    umlaut_request.dispatched_services.reset
+    
+    queued_service_ids = []
+    self.get_service_definitions.each do |service|
+      service_id = service['service_id']
+      # use in-memory #to_a search, don't go to db each time!
+      if found = umlaut_request.dispatched_services.to_a.find {|s| s.service_id == service_id}
+        queued_service_ids.push(service_id) if found.status == DispatchedService::Queued
+      else
+        umlaut_request.new_dispatch_object!(service_id, DispatchedService::Queued).save!
+        queued_service_ids.push(service_id)
+      end        
+    end
+    
+
+    
+    # Now actually dispatch. 
+    
+    # Foreground services
+    (0..9).each do | priority |      
+      services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)
+      next if services_to_run.empty?      
+      ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
+    end
+    
+    # Need to reload the request from db, so it gets changes
+    # made by services in threads. 
+    umlaut_request.reload
+    
+    # Now we run background services.
+    # Now we do some crazy magic, start a Thread to run our background
+    # services. We are NOT going to wait for this thread to join,
+    # we're going to let it keep doing it's thing in the background after
+    # we return a response to the browser
+    backgroundThread = Thread.new(self, umlaut_request) do | t_collection,  t_request|
+      # Tell our AR extension not to allow implicit checkouts
+      ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
+      
+      # got to reserve an AR connection for our main 'background traffic director'
+      # thread, so it has a connection to use to mark services as failed, at least. 
+      ActiveRecord::Base.connection_pool.with_connection do
+        begin
+          # Deal with ruby's brain dead thread scheduling by setting
+          # bg threads to a lower priority so they don't interfere with fg
+          # threads.
+          Thread.current.priority = -1          
+        
+          ('a'..'z').each do | priority |
+            services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)        
+            next if services_to_run.empty?      
+            ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)                               
+          end        
+       rescue Exception => e
+         #debugger
+          # We are divorced from any request at this point, not much
+          # we can do except log it. Actually, we'll also store it in the
+          # db, and clean up after any dispatched services that need cleaning up.
+          # If we're catching an exception here, service processing was
+          # probably interrupted, which is bad. You should not intentionally
+          # raise exceptions to be caught here.
+          Thread.current[:exception] = e
+          logger.error("Background Service execution exception1: #{e}\n\n   " + clean_backtrace(e).join("\n"))                
+       end
+     end
+    end
+
+    
+    
+  end
+  
+  def completed_dispatch_expired?(ds)
+    interval = self.response_expire_interval
+    crontab = self.response_expire_crontab_format
+    now = Time.now
+    
+    return nil unless interval || crontab 
+    
+    expired_interval = interval && (now - ds.created_at > interval)
+    expired_crontab = crontab && (now > CronTab.new(crontab).nexttime(ds.created_at))
+    
+    return expired_interval || expired_crontab
+  end
+  
+  
+  
+
+  # Instantiate new copies of services included in this collection, which
+  # services specified by options, can combine:
+  # :task => Service::StandardTask (default) or Service::LinkOutFilterTask
+  # :level => priority level, default to returning services from all.
+  # :ids => list of id's, only those. 
+  def instantiate_services!(options ={})
+    get_service_definitions(options).collect do |svc_def|
+      ServiceStore.instantiate_service!(svc_def, umlaut_request)
+    end
+  end
+      
+
+  # Deprecated, use #instantiate_services! with :task => Service::LinkOutFilter.
+  def link_out_service_level(level)
+    instantiate_services!(:task => Service::LinkOutFilterTask, 
+                          :level => level)
+  end
+
+  
+
+  # Get service definition hashes for services in this institution.
+  # options, returned in an array. 
+  # Does return a mutatable array that Collection mutates
+  # internally, but clients really ought not to mutate. 
+  # :task => Service::StandardTask (default) or Service::LinkOutFilterTask
+  # :level => priority level, default to returning services from all. 
+  # :ids => list of service unique ids, return only these. 
+  def get_service_definitions(options = {})
+    options[:task] ||= Service::StandardTask
+    
+    configs_for_task = @service_definitions[ options[:task] ] || {}
+    
+    service_configs = case options[:level]
+                        when nil
+                          # All of of them for this task
+                          configs_for_task.values.flatten
+                        else
+                          configs_for_task[ options[:level] ] || []
+                      end
+     if options[:ids]
+       service_configs = service_configs.find_all {|s| options[:ids].include? s["service_id"] }
+     end
+                                                      
+     return service_configs 
+  end
+
+  protected
+  
+  # Arrange services in hash according to task type and priority. 
+  def gather_services
+    @service_definitions_flat.each_pair do | unique_id, svc_def |
+      next if svc_def.nil?
+    
+      svc_def['service_id'] = unique_id
+      task = svc_def['task'] || Service::StandardTask
+      level = svc_def['priority'] || 3
+      
+      @service_definitions[task] ||= {}
+      @service_definitions[task][level] ||= []
+      @service_definitions[task][level] << svc_def                              
+    end          
+  end
+
+  
+  
+
+
+end