sequenceserver 0.7.9 → 0.8.0

data/lib/sequenceserver.rb

@@ -93,8 +93,7 @@ module SequenceServer
       # blast methods (executables) and their corresponding absolute path
       set :binaries,  {}
 
-      # list of sorted blast databases grouped by databse type:
-      # 'protein', or 'nucleotide'
+      # list of blast databases indexed by their hash value
       set :databases, {}
     end
 
@@ -186,10 +185,8 @@ module SequenceServer
         self.databases = scan_blast_db(database, binaries['blastdbcmd']).freeze
 
         # Log the discovery of databases.
-        databases.each do |type, dbs|
-          dbs.each do |d|
-            log.info("Found #{type} database: #{d.title} at #{d.name}")
-          end
+        databases.each do |id, database|
+          log.info("Found #{database.type} database: #{database.title} at #{database.name}")
         end
       rescue IOError => error
         log.fatal("Fail: #{error}")
@@ -221,48 +218,60 @@ module SequenceServer
       erb :search
     end
 
-    post '/' do
-      method        = params['method']
-      db_type_param = params['db']
-      sequence      = params[:sequence]
+    before '/' do
+      pass if params.empty?
 
-      # evaluate empty sequence as nil, otherwise as fasta
-      sequence = sequence.empty? ? nil : to_fasta(sequence)
+      # ensure required params present
+      #
+      # If a required parameter is missing, SequnceServer returns 'Bad Request
+      # (400)' error.
+      #
+      # See Twitter's [Error Codes & Responses][1] page for reference.
+      #
+      # [1]: https://dev.twitter.com/docs/error-codes-responses
 
-      # Raise ArgumentError if there is no database selected
-      if db_type_param.nil?
-        raise ArgumentError, "No BLAST database selected"
+      if params[:method].nil? or params[:method].empty?
+         halt 400, "No BLAST method provided."
       end
-      db_type = db_type_param.first.first
 
-      # can not proceed if one of these is missing
-      raise ArgumentError unless sequence and db_type and method
-      settings.log.info("requested #{method} against #{db_type.to_s} database")
+      if params[:sequence].nil? or params[:sequence].empty?
+         halt 400, "No input sequence provided."
+      end
 
-      # only allowed blast methods should be used
-      blast_methods = %w|blastn blastp blastx tblastn tblastx|
-      raise ArgumentError, "wrong method: #{method}" unless blast_methods.include?(method)
+      if params[:databases].nil?
+         halt 400, "No BLAST database provided."
+      end
 
-      # check if input_fasta is compatible with the selected blast method
-      sequence_type       = type_of_sequences(sequence)
-      settings.log.debug('sequence: ' + sequence)
-      settings.log.debug('input seq type: ' + sequence_type.to_s)
-      settings.log.debug('blast db type:  ' + db_type)
-      settings.log.debug('blast method:   ' + method)
+      # ensure params are valid #
 
-      unless blast_methods_for(sequence_type).include?(method)
-        raise ArgumentError, "Cannot #{method} a #{sequence_type} query."
+      # only allowed blast methods should be used
+      blast_methods = %w|blastn blastp blastx tblastn tblastx|
+      unless blast_methods.include?(params[:method])
+        halt 400, "Unknown BLAST method: #{params[:method]}."
       end
 
-      # check if selected db is comaptible with the selected blast method
-      allowed_db_type     = db_type_for(method)
-      unless allowed_db_type.to_s == db_type
-        raise ArgumentError, "Cannot #{method} against a #{db_type} database.
-      Need #{allowed_db_type} database."
+      # check the advanced options are sensible
+      begin #FIXME
+        validate_advanced_parameters(params[:advanced])
+      rescue ArgumentError => error
+        halt 400, "Advanced parameters invalid: #{error}"
       end
 
+      # log params
+      settings.log.debug('method: '   + params[:method])
+      settings.log.debug('sequence: ' + params[:sequence])
+      settings.log.debug('database: ' + params[:databases].inspect)
+      settings.log.debug('advanced: ' + params[:advanced])
+    end
+
+    post '/' do
+      method        = params['method']
+      databases     = params[:databases]
+      sequence      = params[:sequence]
       advanced_opts = params['advanced']
-      validate_advanced_parameters(advanced_opts) #check the advanced options are sensible
+
+      # evaluate empty sequence as nil, otherwise as fasta
+      sequence = sequence.empty? ? nil : to_fasta(sequence)
 
       # blastn implies blastn, not megablast; but let's not interfere if a user
       # specifies `task` herself
@@ -270,29 +279,21 @@ module SequenceServer
         advanced_opts << ' -task blastn '
       end
 
-      method = settings.binaries[ method ]
-      settings.log.debug('settings.databases:   ' + settings.databases.inspect)
-      databases = params['db'][db_type].map{|index|
-        settings.databases[db_type][index.to_i].name
+      method    = settings.binaries[ method ]
+      databases = params[:databases].map{|index|
+        settings.databases[index].name
       }
 
-      # run blast to blast archive
-      blast = Blast.blast_string_to_blast_archive(method, databases.join(' '), sequence, advanced_opts)
-      # log the command that was run
-      settings.log.info('Ran to blast archive: ' + blast.command) if settings.logging
-
-      # convert blast archive to HTML version
-      blast.convert_blast_archive_to_html_result(settings.binaries['blast_formatter'])
-      # log the command that was run
-      settings.log.info('Ran to get HTML output: ' + blast.command) if settings.logging
+      # run blast and log
+      blast = Blast.new(method, sequence, databases.join(' '), advanced_opts)
+      blast.run!
+      settings.log.info('Ran: ' + blast.command)
 
-      @blast = format_blast_results(blast.result, databases)
-
-      if request.xhr?
-        return @blast
+      unless blast.success?
+        halt *blast.error
       end
 
-      erb :search
+      format_blast_results(blast.result, databases)
     end
 
     # get '/get_sequence/?id=sequence_ids&db=retreival_databases'
@@ -372,9 +373,6 @@ HEADER
     end
 
     def format_blast_results(result, databases)
-      raise ArgumentError, 'Problem: empty result! Maybe your query was invalid?' if !result.class == String
-      raise ArgumentError, 'Problem: empty result! Maybe your query was invalid?' if result.empty?
-
       formatted_result = ''
       @all_retrievable_ids = []
       string_of_used_databases = databases.join(' ')

data/lib/sequenceserver/blast.rb

@@ -1,200 +1,93 @@
 require 'tempfile'
-require 'open3'
 
 module SequenceServer
-  # Simple ncbi-blast wrapper. Check examples below.
+  # Simple BLAST+ wrapper.
   class Blast
-    # blast method
-    attr_accessor :method
 
-    # database name
-    attr_accessor :db
-
-    # query sequence string
-    attr_accessor :qstring
-
-    # query file name
-    attr_accessor :qfile
-
-    # advanced blast options
-    attr_accessor :options
+    ERROR_LINE = /\(CArgException.*\)\s(.*)/
 
     # command string to be executed
-    attr_reader   :command
+    attr_reader :command
 
     # result of executing command
-    attr_reader   :result
+    attr_reader :result
 
-    # blast archive file output
-    attr_reader   :blast_archive_tempfile
-
-    # errors if any while executing command
-    attr_reader   :error
+    # errors as [status, message]
+    attr_reader :error
 
     # Initialize a new blast search.
     # ---
-    # Arguments(optional):
-    # * method(String)  - blast executable (shell executable, or absolute path)
-    # * db(String)      - database name as returned by 'blastdbcmd -list'
-    # * query(Hash)     - query string/file, and options.
-    #
-    # In the query Hash, use:
-    # * :qfile(String)   - to run Blast against a file.
-    # * :qstrin(String)  - to run Blast against a string.
-    # * :options(String) - to specify multiple blast options.
+    # Arguments:
+    # * method (String)    - blast executable (shell executable, or absolute path)
+    # * query (String)     - query string
+    # * databases (String) - database name as returned by 'blastdbcmd -list'
+    # * options (String)   - other options
     #
-    # Either :qfile, or :qstring should be used. If both are given, by design
-    # :qstring will be used to run blast.
     # ---
     # Examples:
     #
-    #   b = Blast.new("blastn", "S.cdna.fasta", :qfile => 'query.seq', :options => "-html -num_threads 4")
-    #   b = Blast.new("blastn", "S.cdna.fasta", :qstring => 'ATGTCCGCGAATCGATTGAACGTGCTGGTGACCCTGATGCTCGCCGTCGCGCTTCTTGTG')
+    #   b = Blast.new("blastn", 'ATGTCCGCGAATCGATTGAACGTGCTGGTGACCCTGATGCTCGCCGTCGCGCTTCTTGTG', "S.cdna.fasta",  "-html -num_threads 4")
     #
     #   b.run!        => true
     #   b.result      => "blast output"
-    #
-    #   # change the blast method.
-    #   b.method = 'blastp'
-    #
-    #   b.run!        => false
-    #   b.error       => "blast error output"
-    def initialize(method = nil, db = nil, query = {})
-      @method  = method
-      @db      = db
-      @qstring = query[:qstring]
-      @qfile   = query[:qfile]
-      @options = query[:options]
+    def initialize(method, query, databases, options = nil)
+      @method    = method
+      @databases = databases
+
+      # create a tempfile for the given query
+      qfile = Tempfile.new('sequenceserver_query')
+      qfile.puts(query)
+      qfile.close
+      @query = qfile.path
+
+      # Add -outfmt 11 to list of options so that it outputs a blast archive
+      @options = options.to_s
+      @options += " -html"
     end
 
     # Run blast everytime it is called. Returns the success
-    # status - true, or false. Blast method, db, and qfile/qstring
-    # need to be set before calling this method, else blast will fail.
-    #
-    #   b = Blast.new
-    #   b.run!   => false
-    #
-    #   # set blast method, and db
-    #   b.method = 'blastn'
-    #   b.db     = 'S.cdna.fasta'
-    #
-    #   b.run!   => false
-    #   b.errors => "blast error output"
-    #
-    #   # set qfile
-    #   b.qfile  = 'query1.seq'    
-    #
-    #   b.run!   => true
-    #   b.reuslt => "blast output"
+    # status - true, or false.
     def run!
-      # can not run blast if method is not specified
-      return false unless @method
-
-      # create a tempfile if qstring is given
-      if @qstring
-        @tempfile = Tempfile.new('qfile')
-        @tempfile.puts(qstring)
-        @tempfile.close
-        @qfile    = @tempfile.path
-      end
+      @result, @error, status = execute(command)
 
-      # form command to execute
-      @command = to_s
+      status == 0 and return @success = true
 
-      # execute command and capture both stdout, and stderr
-      Open3.popen3(@command) do |stdin, stdout, stderr|
-        @result = stdout.readlines # convert to string?
-        @error  = stderr.readlines
+      if status == 1
+        message = @error.each{|l| l.match(ERROR_LINE) and break Regexp.last_match[1]}
+        message = message || @error
+        @error  = [400,  message]
+      else
+        @error = [500, @error]
       end
 
-      # set and return success status
-      return @success = @error.empty?
-
-    ensure
-      # delete tempfile if it was created
-      @tempfile.unlink if @tempfile
+      false
     end
 
-    # Return the blast type used as a String.
-    #
-    #   b.method = '/home/yeban/opt/blastn'
-    #   b.type   => 'blastn'
-    def type
-      @type ||= @method[(@method.rindex('/') + 1)..-1]
+    # The command that will be executed.
+    def command
+      @command ||= "#@method -db '#@databases' -query '#@query' #@options"
     end
 
-    # Return success status - true, false, or nil.
-    # 'nil' implies that blast has not been run yet.
+    # Return success status.
     def success?
       @success
     end
 
-    # String representation of the blast object - same as
-    # the command to be executed.
-    def to_s
-      s = "#@method "
-      s << "-db '#@db' " if @db
-      s << "-query #@qfile " if @qfile
-      s << @options.to_s if @options
-      s
-    end
+    private
 
-    # Especially helpful in irb - "status : command"
-    def inspect
-      return to_s if success?.nil?
-      (success? ? "success : " : "fail : ") + @command
-    end
+    # Execute a command and return its stdout, stderr, and exit status.
+    def execute(command)
+      rfile = Tempfile.new('sequenceserver_result')
+      efile = Tempfile.new('sequenceserver_error')
+      [rfile, efile].each {|file| file.close}
 
-    # Run the blast with the options specified by the user, returning a blast archive file, which can be further transformed into other formats
-    def run_to_blast_archive!
-      @blast_archive_tempfile = Tempfile.open('seqserve_formatter')
-
-      # Add -outfmt 11 to list of options so that it outputs a blast archive
-      @options ||= ''
-      @options += " -outfmt 11 -out #{@blast_archive_tempfile.path}"
+      system("#{command} > #{rfile.path} 2> #{efile.path}")
+      status = $?.exitstatus
 
-      # Run the blast
-      run!
-      return @success unless @success
-    end
-
-    # convert the blast archive to a regular HTML result, stored
-    # as an instance variable Blast#result
-    def convert_blast_archive_to_html_result(blast_formatter_path)
-      @command = "#{blast_formatter_path} -archive #{blast_archive_tempfile.path} -html"
-
-      # execute command and capture both stdout, and stderr
-      Open3.popen3(@command) do |stdin, stdout, stderr|
-      @result = stdout.readlines # convert to string?
-      @error  = stderr.readlines
-      end
-    end
-
-    class << self
-      # shortcut method to run blast against a query file
-      def blast_file(method, db, qfile, options = nil)
-        b = Blast.new(method, db, :qfile => qfile, :options => options)
-        b.run!
-        b
-      end
-
-      # shortcut method to run blast against a query string
-      def blast_string(method, db, qstring, options = nil)
-        b = Blast.new(method, db, :qstring => qstring, :options => options)
-        b.run!
-        b
-      end
-
-      # shortcut method to run blast with a query string and return a
-      # blast archive, which can then be further processed into other useful
-      # output forms (e.g. HTML, GFF). If it ran successfully, the blast archive
-      # is a Tempfile accessible as an instance variable of the returned
-      # Blast object.
-      def blast_string_to_blast_archive(method, db, qstring, options = nil)
-        b = Blast.new(method, db, :qstring => qstring, :options => options)
-        b.run_to_blast_archive!
-        b
-      end
+      return File.readlines(rfile.path), File.readlines(efile.path), status
+    ensure
+      rfile.unlink
+      efile.unlink
     end
   end
 end

data/lib/sequenceserver/database.rb

@@ -1,7 +1,9 @@
+require 'digest/md5'
+
 module SequenceServer
-  class Database < Struct.new("Database", :name, :title)
+  class Database < Struct.new("Database", :name, :title, :type)
     def to_s
-      "#{title} #{name}"
+      "#{type}: #{title} #{name}"
     end
 
     # Its not very meaningful to compare Database objects, however,
@@ -19,5 +21,9 @@ module SequenceServer
         self.name <=> other.name
       end
     end
+
+    def hash
+      @hash ||= Digest::MD5.hexdigest(self.name)
+    end
   end
 end

data/lib/sequenceserver/helpers.rb

@@ -92,29 +92,21 @@ module SequenceServer
         db_list.each_line do |line|
           next if line.empty?  # required for BLAST+ 2.2.22
           type, name, *title =  line.split(' ') 
-          type = type.downcase
+          type = type.downcase.intern
           name = name.freeze
           title = title.join(' ').freeze
 
           # skip past all but alias file of a NCBI multi-part BLAST database
-          if name.match(/\/\w*[.]\d{2,}[.\w]*/)
+          if multipart_database_name?(name)
             log.info(%|Found a multi-part database volume at #{name} - ignoring it.|)
             next
           end
 
           #LOG.info("Found #{type} database: #{title} at #{name}")
-          (db[type] ||= []) << Database.new(name, title)
+          database = Database.new(name, title, type)
+          db[database.hash] = database
         end
 
-
-        # the erb would fail as calling nil.each_with_index if a dbtype was undefined. 
-        db['protein']    = [] unless db.keys.include?('protein')
-        db['nucleotide'] = [] unless db.keys.include?('nucleotide')
-
-        # sort the list of dbs
-        db['protein'].sort!
-        db['nucleotide'].sort!
-
         db 
       end
 
@@ -125,6 +117,16 @@ module SequenceServer
       def command?(command)
         system("which #{command} > /dev/null 2>&1")
       end
+
+      # Returns true if the database name appears to be a multi-part database name.
+      #
+      # e.g.
+      # /home/ben/pd.ben/sequenceserver/db/nr.00 => yes
+      # /home/ben/pd.ben/sequenceserver/db/nr => no
+      # /home/ben/pd.ben/sequenceserver/db/img3.5.finished.faa.01 => yes
+      def multipart_database_name?(db_name)
+        !(db_name.match(/.+\/\S+\d{2}$/).nil?)
+      end
     end
 
     def self.included(klass)