sequenceserver 1.0.0.pre.2 → 1.0.0.pre.3

data/lib/sequenceserver.rb

@@ -1,27 +1,22 @@
 require 'yaml'
+require 'English'
 require 'fileutils'
 require 'sinatra/base'
 require 'thin'
 require 'json'
 
+require 'sequenceserver/exceptions'
+require 'sequenceserver/config'
 require 'sequenceserver/logger'
 require 'sequenceserver/sequence'
 require 'sequenceserver/database'
 require 'sequenceserver/blast'
 
+# Top level module / namespace.
 module SequenceServer
-
   # Use a fixed minimum version of BLAST+
   MINIMUM_BLAST_VERSION           = '2.2.30+'
 
-  # Use the following exit codes, or 1.
-  EXIT_BLAST_NOT_INSTALLED        = 2
-  EXIT_BLAST_NOT_COMPATIBLE       = 3
-  EXIT_NO_BLAST_DATABASE          = 4
-  EXIT_BLAST_INSTALLATION_FAILED  = 5
-  EXIT_CONFIG_FILE_NOT_FOUND      = 6
-  EXIT_NO_SEQUENCE_DIR            = 7
-
   class << self
     def environment
       ENV['RACK_ENV']
@@ -40,80 +35,53 @@ module SequenceServer
     end
 
     def init(config = {})
-      @config_file = config.delete(:config_file) || '~/.sequenceserver.conf'
-      @config_file = File.expand_path(config_file)
-      assert_file_present('config file', config_file, EXIT_CONFIG_FILE_NOT_FOUND)
-
-      @config = {
-        :num_threads  => 1,
-        :port         => 4567,
-        :host         => 'localhost'
-      }.update(parse_config_file.merge(config))
-
-      if @config[:bin]
-        @config[:bin] = File.expand_path @config[:bin]
-        assert_dir_present 'bin dir', @config[:bin]
-        export_bin_dir
-      end
-
-      assert_blast_installed_and_compatible
-
-      assert_dir_present 'database dir', @config[:database_dir], EXIT_NO_SEQUENCE_DIR
-      @config[:database_dir] = File.expand_path(@config[:database_dir])
-      assert_blast_databases_present_in_database_dir
+      @config = Config.new(config)
 
-      Database.scan_databases_dir
-
-      @config[:num_threads] = Integer(@config[:num_threads])
-      assert_num_threads_valid @config[:num_threads]
-      logger.debug("Will use #{@config[:num_threads]} threads to run BLAST.")
-
-      if @config[:require]
-        @config[:require] = File.expand_path @config[:require]
-        assert_file_present 'extension file', @config[:require]
-        require @config[:require]
-      end
+      init_binaries
+      init_database
+      load_extension
+      check_num_threads
+      self
 
       # We don't validate port and host settings. If SequenceServer is run
       # self-hosted, bind will fail on incorrect values. If SequenceServer
       # is run via Apache+Passenger, we don't need to worry.
-
-      self
     end
 
-    attr_reader :config_file, :config
-
-    def [](key)
-      config[key]
-    end
+    attr_reader :config
 
     # Run SequenceServer as a self-hosted server using Thin webserver.
     def run
+      check_host
       url = "http://#{config[:host]}:#{config[:port]}"
-      server = Thin::Server.new(config[:host], config[:port], :signals => false) do
+      server = Thin::Server.new(config[:host],
+                                config[:port],
+                                :signals => false) do
         use Rack::CommonLogger
         run SequenceServer
       end
       server.silent = true
       server.backend.start do
-        puts "** SequenceServer is ready."
+        puts '** SequenceServer is ready.'
         puts "   Go to #{url} in your browser and start BLASTing!"
-        puts "   Press CTRL+C to quit."
+        puts '   Press CTRL+C to quit.'
         [:INT, :TERM].each do |sig|
           trap sig do
             server.stop!
             puts
-            puts "** Thank you for using SequenceServer :)."
-            puts "   Please cite: "
-            puts "             Priyam, Woodcroft, Rai & Wurm,"
-            puts "             SequenceServer (in prep)."
+            puts '** Thank you for using SequenceServer :).'
+            puts '   Please cite: '
+            puts '             Priyam, Woodcroft, Rai & Wurm,'
+            puts '             SequenceServer (in prep).'
           end
         end
       end
     rescue
-      puts "** Oops! There was an error."
+      puts '** Oops! There was an error.'
       puts "   Is SequenceServer already accessible at #{url}?"
-      puts "   Try running SequenceServer on another port, like so: sequenceserver -p 4570."
+      puts '   Try running SequenceServer on another port, like so:'
+      puts
+      puts '       sequenceserver -p 4570.'
     end
 
     # Rack-interface.
@@ -137,105 +105,105 @@ module SequenceServer
 
     private
 
-    def parse_config_file
-      logger.debug("Reading configuration file: #{config_file}.")
-      config = YAML.load_file(config_file) || {}
-
-      # Symbolize hash keys
-      config = config.inject({}){|c, e| c[e.first.to_sym] = e.last; c}
-
-      # The newer config file version replaces the older database key with
-      # database_dir. If an older version is found, we auto-migrate it to
-      # newer one.
-      config[:database_dir] ||= config.delete(:database)
-      config
-    rescue ArgumentError => error
-      puts "*** Error in config file: #{error}."
-      puts "    YAML is white space sensitive. Is your config file properly indented?"
-      exit 1
+    def init_binaries
+      if config[:bin]
+        config[:bin] = File.expand_path config[:bin]
+        unless File.exist?(config[:bin]) && File.directory?(config[:bin])
+          fail BIN_DIR_NOT_FOUND, config[:bin]
+        end
+        logger.debug("Will use NCBI BLAST+ at: #{config[:bin]}")
+        export_bin_dir
+      else
+        logger.debug('Will use NCBI BLAST+ at: $PATH')
+      end
+
+      assert_blast_installed_and_compatible
     end
 
-    def write_config_file
-      File.open(SequenceServer.config_file, 'w') do |f|
-        f.puts(config.delete_if{|k, v| v.nil?}.to_yaml)
+    def init_database
+      fail DATABASE_DIR_NOT_SET unless config[:database_dir]
+
+      config[:database_dir] = File.expand_path(config[:database_dir])
+      unless File.exist?(config[:database_dir]) &&
+             File.directory?(config[:database_dir])
+        fail DATABASE_DIR_NOT_FOUND, config[:database_dir]
+      end
+
+      assert_blast_databases_present_in_database_dir
+      logger.debug("Will use BLAST+ databases at: #{config[:database_dir]}")
+
+      Database.scan_databases_dir
+      Database.each do |database|
+        logger.debug("Found #{database.type} database '#{database.title}'" \
+                     " at '#{database.name}'")
       end
     end
 
-    # Export NCBI BLAST+ bin dir to PATH environment variable.
-    def export_bin_dir
-      bin_dir = config[:bin]
-      if bin_dir
-        unless ENV['PATH'].split(':').include? bin_dir
-          ENV['PATH'] = "#{bin_dir}:#{ENV['PATH']}"
-        end
+    def check_num_threads
+      num_threads = Integer(config[:num_threads])
+      fail NUM_THREADS_INCORRECT unless num_threads > 0
+
+      logger.debug "Will use #{num_threads} threads to run BLAST."
+      if num_threads > 256
+        logger.warn "Number of threads set at #{num_threads} is unusually high."
       end
+    rescue
+      raise NUM_THREADS_INCORRECT
     end
 
-    def assert_file_present desc, file, exit_code = 1
-      unless file and File.exists? File.expand_path file
-        puts "*** Couldn't find #{desc}: #{file}."
-        exit exit_code
+    # Check and warn user if host is 0.0.0.0 (default).
+    def check_host
+      # rubocop:disable Style/GuardClause
+      if config[:host] == '0.0.0.0'
+        logger.warn 'Will listen on all interfaces (0.0.0.0).' \
+                    ' Consider using 127.0.0.1 (--host option).'
       end
+      # rubocop:enable Style/GuardClause
     end
 
-    alias assert_dir_present assert_file_present
+    def load_extension
+      return unless config[:require]
 
-    def assert_blast_installed_and_compatible
-      unless command? 'blastdbcmd'
-        puts "*** Could not find BLAST+ binaries."
-        exit EXIT_BLAST_NOT_INSTALLED
-      end
-      version = %x|blastdbcmd -version|.split[1]
-      unless version >= MINIMUM_BLAST_VERSION
-        puts "*** Your BLAST+ version #{version} is outdated."
-        puts "    SequenceServer needs NCBI BLAST+ version #{MINIMUM_BLAST_VERSION} or higher."
-        exit EXIT_BLAST_NOT_COMPATIBLE
+      config[:require] = File.expand_path config[:require]
+      unless File.exist?(config[:require]) && File.file?(config[:require])
+        fail EXTENSION_FILE_NOT_FOUND, config[:require]
       end
+
+      logger.debug("Loading extension: #{config[:require]}")
+      require config[:require]
     end
 
-    def assert_blast_databases_present_in_database_dir
-      database_dir = config[:database_dir]
-      out = %x|blastdbcmd -recursive -list #{database_dir}|
-      if out.empty?
-        puts "*** Could not find BLAST databases in '#{database_dir}'."
-        exit EXIT_NO_BLAST_DATABASE
-      elsif out.match(/BLAST Database error/) or not $?.success?
-        puts "*** Error obtaining BLAST databases."
-        puts "    Tried: #{find_dbs_command}"
-        puts "    Error:"
-        out.strip.split("\n").each do |l|
-          puts "      #{l}"
-        end
-        puts "    Please could you report this to 'https://groups.google.com/forum/#!forum/sequenceserver'?"
-        exit EXIT_BLAST_DATABASE_ERROR
-      end
+    # Export NCBI BLAST+ bin dir to PATH environment variable.
+    def export_bin_dir
+      bin_dir = config[:bin]
+      return unless bin_dir
+      return if ENV['PATH'].split(':').include? bin_dir
+      ENV['PATH'] = "#{bin_dir}:#{ENV['PATH']}"
     end
 
-    def assert_num_threads_valid num_threads
-      unless num_threads > 0
-        puts "*** Can't use #{num_threads} number of threads."
-        puts "    Number of threads should be greater than or equal to 1."
-        exit 1
-      end
-      if num_threads > 256
-        logger.warn "*** Number of threads set at #{num_threads} is unusually high."
-      end
-    rescue
-      puts "*** Number of threads should be a number."
-      exit 1
+    def assert_blast_installed_and_compatible
+      fail BLAST_NOT_INSTALLED unless command? 'blastdbcmd'
+      version = `blastdbcmd -version`.split[1]
+      fail BLAST_NOT_COMPATIBLE, version unless version >= MINIMUM_BLAST_VERSION
     end
 
+    def assert_blast_databases_present_in_database_dir
+      cmd = "blastdbcmd -recursive -list #{config[:database_dir]}"
+      out = `#{cmd}`
+      errpat = /BLAST Database error/
+      fail NO_BLAST_DATABASE_FOUND, config[:database_dir] if out.empty?
+      fail BLAST_DATABASE_ERROR, cmd, out if out.match(errpat) ||
+                                             !$CHILD_STATUS.success?
+    end
 
     # Return `true` if the given command exists and is executable.
     def command?(command)
       system("which #{command} > /dev/null 2>&1")
     end
-
   end
 
   # Controller.
   class App < Sinatra::Base
-
     # See
     # http://www.sinatrarb.com/configuration.html
     configure do
@@ -254,7 +222,7 @@ module SequenceServer
       # or http_status` methods. Error blocks errors must explicitly set http
       # status, if needed, by calling `status` method.
       # method.
-      enable  :dump_errors
+      enable :dump_errors
 
       # We don't want Sinatra do setup any loggers for us. We will use our own.
       set :logging, nil
@@ -267,6 +235,13 @@ module SequenceServer
     # http://www.sinatrarb.com/intro.html#Mime%20Types
     configure do
       mime_type :fasta, 'text/fasta'
+      mime_type :xml,   'text/xml'
+      mime_type :tsv,   'text/tsv'
+    end
+
+    configure :production do
+      set :public_folder,
+          lambda { File.join SequenceServer.root, 'public', 'dist' }
     end
 
     helpers do
@@ -274,16 +249,16 @@ module SequenceServer
       #
       # See links.rb for example of a Hash object that will be rendered.
       def a(link)
-        return unless link[:title] and link[:url]
-        _a = ["<a"]
-        _a <<   "href=#{link[:url]}"
-        _a <<   "class=\"#{link[:class]}\"" if link[:class]
-        _a <<   "target=\"_blank\""         if absolute? link[:url]
-        _a << '>'
-        _a <<   "<i class=\"fa #{link[:icon]}\"></i>" if link[:icon]
-        _a <<   link[:title]
-        _a << "</a>"
-        _a.join("\n")
+        return unless link[:title] && link[:url]
+        a = ['<a']
+        a <<   "href=#{link[:url]}"
+        a <<   "class=\"#{link[:class]}\"" if link[:class]
+        a <<   "target=\"_blank\""         if absolute? link[:url]
+        a << '>'
+        a <<   "<i class=\"fa #{link[:icon]}\"></i>" if link[:icon]
+        a <<   link[:title]
+        a << '</a>'
+        a.join("\n")
       end
 
       # Is the given URI absolute? (or relative?)
@@ -291,19 +266,34 @@ module SequenceServer
         URI.parse(uri).absolute?
       end
 
-      # Formats score (a float) to two decimal places.
-      def prettify_score(score)
-        '%.2f' % score
+      # Prettify given data.
+      def prettify(data)
+        return prettify_tuple(data) if tuple? data
+        return prettify_float(data) if data.is_a? Float
+        data
       end
 
-      # Formats evalue (a float expressed in scientific notation) to "a x b^c".
-      def prettify_evalue(evalue)
-        evalue.to_s.sub(/(\d*\.\d*)e?([+-]\d*)?/) do
-          s = '%.3f' % Regexp.last_match[1]
-          s << " &times; 10<sup>#{Regexp.last_match[2]}</sup>" if Regexp.last_match[2]
+      # Formats float as "a.bcd" or "a x b^c". The latter if float is
+      # scientific notation. Former otherwise.
+      def prettify_float(float)
+        float.to_s.sub(/(\d*\.\d*)e?([+-]\d*)?/) do
+          base  = Regexp.last_match[1]
+          power = Regexp.last_match[2]
+          s = format '%.2f', base
+          s << " &times; 10<sup>#{power}</sup>" if power
           s
         end
       end
+
+      # Formats an array of two elements as "first (last)".
+      def prettify_tuple(tuple)
+        "#{tuple.first} (#{tuple.last})"
+      end
+
+      # Is the given value a tuple? (array of length two).
+      def tuple?(data)
+        return true if data.is_a?(Array) && data.length == 2
+      end
     end
 
     # For any request that hits the app in development mode, log incoming
@@ -314,15 +304,20 @@ module SequenceServer
 
     # Render the search form.
     get '/' do
-      erb :search, :locals => {:databases => Database.group_by(&:type)}
+      erb :search, :locals => { :databases => Database.group_by(&:type) }
     end
 
     # BLAST search!
     post '/' do
-      erb :result, :locals => {:report => BLAST.run(params)}
+      erb :result, :locals => { :report => BLAST.run(params) }
     end
 
-    # get '/get_sequence/?sequence_ids=sequence_ids&database_ids=retreival_databases[&download=fasta]'
+    # @params sequence_ids: whitespace separated list of sequence ids to
+    # retrieve
+    # @params database_ids: whitespace separated list of database ids to
+    # retrieve the sequence from.
+    # @params download: whether to return raw response or initiate file
+    # download
     #
     # Use whitespace to separate entries in sequence_ids (all other chars exist
     # in identifiers) and retreival_databases (we don't allow whitespace in a
@@ -345,18 +340,26 @@ module SequenceServer
         {
           :sequence_ids => sequence_ids,
           :databases    => Database[database_ids].map(&:title),
-          :sequences    => sequences.map {|s| s.info}
+          :sequences    => sequences.map(&:info)
         }.to_json
       end
     end
 
+    get '/get_report/' do
+      ofile = BLAST.format(params)
+
+      send_file ofile[:filepath],
+                :filename => ofile[:filename],
+                :type => ofile[:type].to_sym
+    end
+
     # This error block will only ever be hit if the user gives us a funny
     # sequence or incorrect advanced parameter. Well, we could hit this block
     # if someone is playing around with our HTTP API too.
     error BLAST::ArgumentError do
       status 400
       error = env['sinatra.error']
-      erb :'400', :locals => {:error => error}
+      erb :'400', :locals => { :error => error }
     end
 
     # This will catch any unhandled error and some very special errors. Ideally
@@ -367,7 +370,7 @@ module SequenceServer
     error Exception, BLAST::RuntimeError do
       status 500
       error = env['sinatra.error']
-      erb :'500', :locals => {:error => error}
+      erb :'500', :locals => { :error => error }
     end
   end
 end