sequenceserver 0.8.9 → 1.0.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 631b0671719d8700180eb7987e01f0a951b68cfa
-  data.tar.gz: 028caff7b7edae94848eaba84dfd48ac5c6f5f81
+  metadata.gz: b4b6422d0e86b47690118cf32a0633609fd8e545
+  data.tar.gz: 01dda58ef4ab7bac5c889508361be848482cfc75
 SHA512:
-  metadata.gz: c1064444047ef36dc19d357bb7ad639a7dd4d4786ff4dee1da8d631dbdacd5bf00530a530d8bb9ba2887616535978f13a1ff1ad7a20974594a3e9dec3bcb99b5
-  data.tar.gz: a1379fe0d72402dc1c76ee8197c7ce1faa2a01e4e5c899cff5679c641b2788f419cbdbe4cbcaa305387ea6c292abb8d5bf285f0244551fc2f8ec64e98959271e
+  metadata.gz: c469b959e1fa91763766a7584b2b8ba6950c057d68319cb5ffc7e7dffe8b903bdff88037264ff9a6e71a6b2914a8c733e061b0c065c6934af6f41e633f01e889
+  data.tar.gz: 6cc6dcf46bbf6e4d93437e284102083de62fb30e35e18f0a6f63461dfbaa27f1fe9e7a019b2bcab48ca84d67b787598dc7fde277dcb9ffaad9c507f64e76b89c

data/{README.txt → README.md}

@@ -2,4 +2,6 @@ Thanks for downloading SequenceServer!
 
 Documentation available at http://www.sequenceserver.com
 
+[![build status](https://secure.travis-ci.org/yannickwurm/sequenceserver.png?branch=master)](https://travis-ci.org/yannickwurm/sequenceserver)
+
 -- Yannick Wurm, Ben Woodcroft, Anurag Priyam

data/bin/sequenceserver

@@ -1,82 +1,282 @@
 #!/usr/bin/env ruby
+require 'readline'
+require 'slop'
 
-require 'rubygems'
-require 'bundler/setup'
-require 'optparse'
-require 'sequenceserver'
+ENV['RACK_ENV'] ||= 'production'
 
-# e.g:
-# sequenceserver --config .sequenceserver.conf format_database
-begin
-  # parse command line till first non-option, removing parsed options from ARGV
-  OptionParser.new do |opts|
-    opts.banner =<<BANNER
+# display name for tools like `ps`
+$PROGRAM_NAME = 'sequenceserver'
 
+begin
+  Slop.parse!(:strict => true, :help => true) do
+    banner <<BANNER
 SUMMARY
 
-  custom, local, BLAST server
+custom, local, BLAST server
 
 USAGE
 
-  sequenceserver [options] [subcommand] [subcommand's options]
+sequenceserver [options]
 
-  Example:
+Example:
 
-    # launch SequenceServer with the given config file
-    $ sequenceserver --config ~/.sequenceserver.ants.conf
+  # launch SequenceServer with the given config file
+  $ sequenceserver -c ~/.sequenceserver.ants.conf
 
-    # use the bundled database formatter utility to prepare databases for use
-    # with SequenceServer
-    $ sequenceserver format-databases
+  # use the bundled database formatter utility to prepare databases for use
+  # with SequenceServer
+  $ sequenceserver -m
 
 DESCRIPTION
 
-  SequenceServer lets you rapidly set up a BLAST+ server with an intuitive user
-  interface for use locally or over the web.
+SequenceServer lets you rapidly set up a BLAST+ server with an intuitive user
+interface for use locally or over the web.
 
-SUB-COMMANDS
+If BLAST+ is not installed on your system, SequenceServer will offer to install
+BLAST+ for you.
 
-  format-databases:
-    prepare BLAST databases for use with SequenceServer
+You should only ever have to point it to a directory of FASTA files.
 
-    Run '#{$0} format-databases -h' for help.
+In a given directory, SequenceServer is able to tell FASTA files that are yet
+to be formatted for use with BLAST+ and format them, and FASTA files that are
+already formatted for use with BLAST+, heuristically skipping all other files
+in the directory. Directories are scanned recursively. Type of sequences in a
+FASTA file is detected automagically. `parse_seqids` option of `makeblastdb` is
+used to create BLAST+ databases.
+BANNER
 
-OPTIONS
+    on 'c', 'config_file=',
+      'Use the given configuration file',
+      :argument => true
 
-BANNER
-    opts.on('-c', '--config CONFIG_FILE', 'Use the given configuration file') do |config_file|
-      SequenceServer::App.config_file = File.expand_path(config_file)
-    end
+    on 'b', 'bin=',
+      'Load BLAST+ binaries from this directory',
+      :argument => true
 
-    opts.on('-v', '--version', 'Print version number of SequenceServer that will be loaded.' ) do |config_file|
-      puts SequenceServer.version
-      exit
-    end
-  end.order!
-
-  # of the remaining items in ARGV, the first one must be a subcommand
-  subcommand = ARGV.shift
-
-  if subcommand
-    # process subcommands now
-
-    case subcommand
-    when 'format-databases'
-      require 'sequenceserver/database_formatter'
-      exit
-    else
-      puts "invalid subcommand: #{subcommand}"
-      puts "Run '#{$0} -h' for help with command line options."
-      exit
+    on 'd', 'database_dir=',
+      'Read FASTA and BLAST database from this directory',
+      :argument => true
+
+    on 'n', 'num_threads=',
+      'Number of threads to use to run a BLAST search',
+      :argument => true
+      #:as       => Integer
+
+    on 'r', 'require=',
+      'Load extension from this file',
+      :argument => true
+
+    on 'h', 'host=',
+      'Host to run SequenceServer on',
+      :argument => true
+
+    on 'p', 'port=',
+      'Port to run SequenceServer on',
+      :argument => true
+
+    on 's', 'set',
+      'Set configuration value in default or given config file'
+
+    on 'm', 'make-blast-databases',
+      'Create BLAST databases'
+
+    on 'l', 'list_databases',
+      'List BLAST databases'
+
+    on 'u', 'list-unformatted-fastas',
+      'List unformatted FASTA files'
+
+    on 'i', 'interactive',
+      'Run SequenceServer in interactive mode'
+
+    on 'D', 'devel',
+      'Start SequenceServer in development mode'
+
+    on '-v', '--version',
+      'Print version number of SequenceServer that will be loaded'
+
+    on '-h', '--help',
+      'Display this help message'
+
+    run do
+      if version?
+        gemspec_file = File.join(File.dirname(__FILE__), '..', 'sequenceserver.gemspec')
+        gemspec = eval File.read gemspec_file
+        puts gemspec.version
+        exit
+      end
+
+      ENV['RACK_ENV'] = 'development' if devel?
+      # Save the state of user terminal
+      stty_save = `stty -g`.chomp
+      # Exit gracefully on SIGINT
+      trap('INT') do
+        puts ''
+        puts 'Aborted.'
+        system('stty', stty_save)
+        exit
+      end
+
+      require 'sequenceserver'
+      begin
+        opts = to_h.delete_if{|k, v| v.nil?}
+        opts.delete :set
+        SequenceServer.init opts
+      rescue SystemExit => e
+        # The aim of following error recovery scenarios is to guide user to a
+        # working SequenceServer installation. We expect to land following
+        # error scenarios either when creating a new SequenceServer (first
+        # time or later), or updating config values using -s CLI option.
+
+        # Try error recovery now.
+        case e.status
+        when SequenceServer::EXIT_CONFIG_FILE_NOT_FOUND
+          # Create an empty configuration file to make SequenceServer happy.
+          File.open(SequenceServer.config_file, 'w') {}
+          puts "    Created."
+          redo
+        when SequenceServer::EXIT_BLAST_NOT_INSTALLED,
+          SequenceServer::EXIT_BLAST_NOT_COMPATIBLE
+
+          # Set a flag so that if we recovered from error resulting config can be
+          # saved. Config will be saved unless invoked with -b option.
+          fetch_option(:set).value = !bin?
+
+          # Ask user if she already has BLAST+ downloaded or offer to download
+          # BLAST+ for her.
+          puts
+          print 'Do you have BLAST+ downloaded already? [y/n] (Default: n): '
+          response = STDIN.gets.to_s.strip
+          if response.match(/^[y]$/i)
+            response = Readline.readline('Where? ').to_s.strip
+            unless File.basename(response) == 'bin'
+              fetch_option(:bin).value = File.join(response, 'bin')
+            end
+            redo
+          end
+
+          puts
+          print "Install BLAST+? [y/n] (Default: y): "
+          response = STDIN.gets.to_s.strip
+          unless response.match(/^[n]$/i)
+            puts
+            puts "*** Installing BLAST+."
+            puts "RUBY_PLATFORM #{RUBY_PLATFORM}"
+
+            version = SequenceServer::MINIMUM_BLAST_VERSION
+            url = case RUBY_PLATFORM
+                  when /i686-linux/   # 32 bit Linux
+                    "ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/#{version.chop}/ncbi-blast-#{version}-ia32-linux.tar.gz"
+                  when /x86_64-linux/ # 64 bit Linux
+                    "ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/#{version.chop}/ncbi-blast-#{version}-x64-linux.tar.gz"
+                  when /darwin/       # Mac
+                    "ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/#{version.chop}/ncbi-blast-#{version}-universal-macosx.tar.gz"
+                  else
+                    puts <<ERR
+------------------------------------------------------------------------
+FAILED!! to install NCBI BLAST+.
+
+We currently support Linux and Mac only (both 32 and 64 bit). If you
+believe you are running a supported platform, please open a support
+ticket titled "#{RUBY_PLATFORM}" at:
+
+https://github.com/yannickwurm/sequenceserver/issues
+------------------------------------------------------------------------
+
+ERR
+                  end
+
+            archive = File.join('/tmp', File.basename(url))
+            system "wget -c #{url} -O #{archive} && mkdir -p ~/.sequenceserver && tar xvf #{archive} -C ~/.sequenceserver"
+            unless $?.success?
+              puts "*** Failed to install BLAST+."
+              puts "    You may need to download BLAST+ from - "
+              puts "     http://www.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Web&PAGE_TYPE=BlastDocs&DOC_TYPE=Download"
+              puts "    Please ensure that you download BLAST+ version
+              #{SequenceServer::MINIMUM_BLAST_VERSION} or higher."
+              exit SequenceServer::EXIT_BLAST_INSTALLATION_FAILED
+            end
+            fetch_option(:bin).value = "~/.sequenceserver/ncbi-blast-#{version}/bin/"
+            redo
+          else
+            exit e.status unless set?
+          end
+        when SequenceServer::EXIT_NO_SEQUENCE_DIR
+          # Ask user for the directory containing sequences or BLAST+
+          # databases.
+
+          # Set a flag so that if we recovered from error resulting config can be
+          # saved. Config will be saved unless invoked with -d option.
+          fetch_option(:set).value = !database_dir?
+
+          puts
+          prompt = 'Where are the sequences you would like to search?' \
+                   ' (Default: current dir) '
+          response = Readline.readline(prompt).to_s.strip
+          fetch_option(:database_dir).value = response
+          redo
+        when SequenceServer::EXIT_NO_BLAST_DATABASE
+          unless list_databases? or list_unformatted_fastas? or make_blast_databases?
+            # Offer user to format the FASTA files.
+            puts
+            print 'Create databases? [y/n] (Default: y): '
+            response = STDIN.gets.to_s.strip
+            unless response.match(/^[n]$/i)
+              puts
+              puts "*** Creating databases."
+              SequenceServer::Database.make_blast_databases
+              redo
+            else
+              exit e.status unless set?
+            end
+          end
+        else
+          exit e.status
+        end
+      end
+
+      if interactive?
+        SequenceServer.irb
+        exit
+      end
+
+      if list_databases?
+        puts SequenceServer::Database.all
+        exit
+      end
+
+      if list_unformatted_fastas? or make_blast_databases?
+        unformatted_fastas = SequenceServer::Database.unformatted_fastas
+        if unformatted_fastas.empty?
+          puts "All FASTA files in #{SequenceServer[:database_dir]} are formatted."
+          exit
+        end
+      end
+
+      if list_unformatted_fastas?
+        puts unformatted_fastas
+        exit
+      end
+
+      if make_blast_databases?
+        SequenceServer::Database.make_blast_databases
+        exit
+      end
+
+      if set?
+        SequenceServer.send :write_config_file
+        exit
+      end
+
+      if fetch_option(:set).value
+        SequenceServer.send :write_config_file
+      end
+
+      SequenceServer.run
     end
   end
-rescue OptionParser::InvalidOption =>e
+rescue Slop::Error => e
   puts e
   puts "Run '#{$0} -h' for help with command line options."
   exit
 end
-
-# display name for tools like `ps`
-$PROGRAM_NAME = 'sequenceserver'
-
-SequenceServer::App.run!

data/config.ru

@@ -1,6 +1,4 @@
-require 'rubygems'
-require 'bundler/setup'
 require 'sequenceserver'
 
-SequenceServer::App.init
-run SequenceServer::App
+SequenceServer.init
+run SequenceServer

data/lib/sequenceserver.rb

@@ -1,527 +1,373 @@
-# sequenceserver.rb
-
-require 'sinatra/base'
 require 'yaml'
-require 'logger'
 require 'fileutils'
-require 'sequenceserver/helpers'
+require 'sinatra/base'
+require 'thin'
+require 'json'
+
+require 'sequenceserver/logger'
+require 'sequenceserver/sequence'
+require 'sequenceserver/database'
 require 'sequenceserver/blast'
-require 'sequenceserver/sequencehelpers'
-require 'sequenceserver/sinatralikeloggerformatter'
-require 'sequenceserver/customisation'
-require 'sequenceserver/version'
 
-# Helper module - initialize the blast server.
 module SequenceServer
-  class App < Sinatra::Base
-    include Helpers
-    include SequenceHelpers
-    include SequenceServer::Customisation
-
-    # Basic configuration settings for app.
-    configure do
-      # enable some builtin goodies
-      enable :session, :logging
 
-      # main application file
-      set :app_file,   File.expand_path(__FILE__)
+  # Use a fixed minimum version of BLAST+
+  MINIMUM_BLAST_VERSION           = '2.2.30+'
 
-      # app root is SequenceServer's installation directory
-      #
-      # SequenceServer figures out different settings, location of static
-      # assets or templates for example, based on app root.
-      set :root,       File.dirname(File.dirname(app_file))
+  # 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
 
-      # path to test database
-      #
-      # SequenceServer ships with test database (fire ant genome) so users can
-      # launch and preview SequenceServer without any configuration, and/or run
-      # test suite.
-      set :test_database, File.join(root, 'tests', 'database')
+  class << self
+    def environment
+      ENV['RACK_ENV']
+    end
 
-      # path to example configuration file
-      #
-      # SequenceServer ships with a dummy configuration file. Users can simply
-      # copy it and make necessary changes to get started.
-      set :example_config_file, File.join(root, 'example.config.yml')
+    def verbose?
+      @verbose ||= (environment == 'development')
+    end
 
-      # path to SequenceServer's configuration file
-      #
-      # The configuration file is a simple, YAML data store.
-      set :config_file, Proc.new{ File.expand_path('~/.sequenceserver.conf') }
+    def root
+      File.dirname(File.dirname(__FILE__))
+    end
 
-      set :log,        Proc.new { Logger.new(STDERR) }
-      log.formatter = SinatraLikeLogFormatter.new()
+    def logger
+      @logger ||= Logger.new(STDERR, verbose?)
     end
 
-    # Local, app configuration settings derived from config.yml.
-    #
-    # A config.yml should contain the settings described in the following
-    # configure block as key, value pairs. See example.config.yml in the
-    # installation directory.
-    configure do
-      # store the settings hash from config.yml; further configuration values
-      # are derived from it
-      set :config,      {}
+    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
 
-      # absolute path to the blast binaries
-      #
-      # A default of 'nil' is indicative of blast binaries being present in
-      # system PATH.
-      set :bin,         Proc.new{ File.expand_path(config['bin']) rescue nil }
+      assert_blast_installed_and_compatible
 
-      # absolute path to the database directory
-      #
-      # As a default use 'database' directory relative to current working
-      # directory of the running app.
-      set :database,    Proc.new{ File.expand_path(config['database']) rescue test_database }
+      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
 
-      # the port number to run Sequence Server standalone
-      set :port,        Proc.new{ (config['port'] or 4567).to_i }
+      Database.scan_databases_dir
 
-      # number of threads to be used during blasting
-      #
-      # This option is passed directly to BLAST+. We use a default value of 1
-      # as a higher value may cause BLAST+ to crash if it was not compiled with
-      # threading support.
-      set :num_threads, Proc.new{ (config['num_threads'] or 1).to_i }
-    end
+      @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.")
 
-    # Lookup tables used by Sequence Server to pick up the right blast binary,
-    # or database. These tables should be populated during app initialization
-    # by scanning bin, and database directories.
-    configure do
-      # blast methods (executables) and their corresponding absolute path
-      set :binaries,  {}
+      if @config[:require]
+        @config[:require] = File.expand_path @config[:require]
+        assert_file_present 'extension file', @config[:require]
+        require @config[:require]
+      end
+
+      # 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.
 
-      # list of blast databases indexed by their hash value
-      set :databases, {}
+      self
     end
 
-    configure :development do
-      log.level     = Logger::DEBUG
+    attr_reader :config_file, :config
+
+    def [](key)
+      config[key]
     end
 
-    configure(:production) do
-      log.level     = Logger::INFO
-      error do
-        erb :'500'
+    # Run SequenceServer as a self-hosted server using Thin webserver.
+    def run
+      url = "http://#{config[:host]}:#{config[:port]}"
+      server = Thin::Server.new(config[:host], config[:port], :signals => false) do
+        use Rack::CommonLogger
+        run SequenceServer
       end
-      not_found do
-        erb :'500'
+      server.silent = true
+      server.backend.start do
+        puts "** SequenceServer is ready."
+        puts "   Go to #{url} in your browser and start BLASTing!"
+        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)."
+          end
+        end
       end
+    rescue
+      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."
     end
 
-    class << self
-      # Run SequenceServer as a self-hosted server.
-      #
-      # By default SequenceServer uses Thin, Mongrel or WEBrick (in that
-      # order). This can be configured by setting the 'server' option.
-      def run!(options={})
-        set options
+    # Rack-interface.
+    #
+    # Inject our logger in the env and dispatch request to our
+    # controller.
+    def call(env)
+      env['rack.logger'] = logger
+      App.call(env)
+    end
 
-        # perform SequenceServer initializations
-        puts "\n== Initializing SequenceServer..."
-        init
+    # Run SequenceServer interactively.
+    def irb
+      ARGV.clear
+      require 'irb'
+      IRB.setup nil
+      IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+      require 'irb/ext/multi-irb'
+      IRB.irb nil, self
+    end
 
-        # find out the what server to host SequenceServer with
-        handler      = detect_rack_handler
-        handler_name = handler.name.gsub(/.*::/, '')
+    private
 
-        puts
-        log.info("Using #{handler_name} web server.")
+    def parse_config_file
+      logger.debug("Reading configuration file: #{config_file}.")
+      config = YAML.load_file(config_file) || {}
 
-        if handler_name == 'WEBrick'
-          puts "\n== We recommend using Thin web server for better performance."
-          puts "== To install Thin: [sudo] gem install thin"
-        end
+      # Symbolize hash keys
+      config = config.inject({}){|c, e| c[e.first.to_sym] = e.last; c}
 
-        url = "http://#{bind}:#{port}"
-        puts "\n== Launched SequenceServer at: #{url}"
-        puts "== Press CTRL + C to quit."
-        handler.run(self, :Host => bind, :Port => port, :Logger => Logger.new('/dev/null')) do |server|
-          [:INT, :TERM].each { |sig| trap(sig) { quit!(server, handler) } }
-          set :running, true
+      # 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
+    end
 
-          # for Thin
-          server.silent = true if handler_name == 'Thin'
-        end
-      rescue Errno::EADDRINUSE, RuntimeError => e
-        puts "\n== Failed to start SequenceServer."
-        puts "== Is SequenceServer already running at: #{url}"
+    def write_config_file
+      File.open(SequenceServer.config_file, 'w') do |f|
+        f.puts(config.delete_if{|k, v| v.nil?}.to_yaml)
       end
+    end
 
-      # Stop SequenceServer.
-      def quit!(server, handler_name)
-        # Use Thin's hard #stop! if available, otherwise just #stop.
-        server.respond_to?(:stop!) ? server.stop! : server.stop
-        puts "\n== Thank you for using SequenceServer :)." +
-             "\n== Please cite: " +
-             "\n==             Priyam A., Woodcroft B.J., Wurm Y (in prep)." +
-             "\n==             Sequenceserver: BLAST searching made easy." unless handler_name =~/cgi/i
+    # 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
       end
+    end
 
-      # Initializes the blast server : executables, database. Exit if blast
-      # executables, and databses can not be found. Logs the result if logging
-      # has been enabled.
-      def init
-        # first read the user supplied configuration options
-        self.config = parse_config
-
-        # empty config file
-        unless config
-          log.warn("Empty configuration file: #{config_file} - will assume default settings")
-          self.config = {}
-        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
+      end
+    end
 
-        # scan for blast binaries
-        self.binaries = scan_blast_executables(bin).freeze
+    alias assert_dir_present assert_file_present
 
-        # Log the discovery of binaries.
-        binaries.each do |command, path|
-          log.info("Found #{command} at #{path}")
-        end
-
-        # scan for blast database
-        self.databases = scan_blast_db(database, binaries['blastdbcmd']).freeze
+    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
+      end
+    end
 
-        # Log the discovery of databases.
-        databases.each do |id, database|
-          log.info("Found #{database.type} database: #{database.title} at #{database.name}")
+    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
-      rescue IOError => error
-        log.fatal("Fail: #{error}")
-        exit
-      rescue ArgumentError => error
-        log.fatal("Error in config.yml: #{error}")
-        puts "YAML is white space sensitive. Is your config.yml properly indented?"
-        exit
-      rescue Errno::ENOENT # config file not found
-        log.info('Configuration file not found')
-        FileUtils.cp(example_config_file, config_file)
-        log.info("Generated a dummy configuration file: #{config_file}")
-        puts "\nPlease edit #{config_file} to indicate the location of your BLAST databases and run SequenceServer again."
-        exit
+        puts "    Please could you report this to 'https://groups.google.com/forum/#!forum/sequenceserver'?"
+        exit EXIT_BLAST_DATABASE_ERROR
       end
+    end
 
-      # Parse config.yml, and return the resulting hash.
-      #
-      # This method uses YAML.load_file to read config.yml. Absence of a
-      # config.yml is safely ignored as the app should then fall back on
-      # default configuration values. Any other error raised by YAML.load_file
-      # is not rescued.
-      def parse_config
-        YAML.load_file( config_file )
+    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
     end
 
-    get '/' do
-      erb :search
+
+    # Return `true` if the given command exists and is executable.
+    def command?(command)
+      system("which #{command} > /dev/null 2>&1")
     end
 
-    before '/' do
-      pass if params.empty?
+  end
 
-      # 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
+  # Controller.
+  class App < Sinatra::Base
 
-      if params[:method].nil? or params[:method].empty?
-         halt 400, "No BLAST method provided."
-      end
+    # See
+    # http://www.sinatrarb.com/configuration.html
+    configure do
+      # We don't need Rack::MethodOverride. Let's avoid the overhead.
+      disable :method_override
+
+      # Ensure exceptions never leak out of the app. Exceptions raised within
+      # the app must be handled by the app. We do this by attaching error
+      # blocks to exceptions we know how to handle and attaching to Exception
+      # as fallback.
+      disable :show_exceptions, :raise_errors
+
+      # Make it a policy to dump to 'rack.errors' any exception raised by the
+      # app so that error handlers don't have to do it themselves. But for it
+      # to always work, Exceptions defined by us should not respond to `code`
+      # or http_status` methods. Error blocks errors must explicitly set http
+      # status, if needed, by calling `status` method.
+      # method.
+      enable  :dump_errors
+
+      # We don't want Sinatra do setup any loggers for us. We will use our own.
+      set :logging, nil
+
+      # Public, and views directory will be found here.
+      set :root,    lambda { SequenceServer.root }
+    end
 
-      if params[:sequence].nil? or params[:sequence].empty?
-         halt 400, "No input sequence provided."
-      end
+    # See
+    # http://www.sinatrarb.com/intro.html#Mime%20Types
+    configure do
+      mime_type :fasta, 'text/fasta'
+    end
 
-      if params[:databases].nil?
-         halt 400, "No BLAST database provided."
+    helpers do
+      # Render an anchor element from the given Hash.
+      #
+      # 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")
       end
 
-      # ensure params are valid #
-
-      # 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]}."
+      # Is the given URI absolute? (or relative?)
+      def absolute?(uri)
+        URI.parse(uri).absolute?
       end
 
-      # check the advanced options are sensible
-      begin #FIXME
-        validate_advanced_parameters(params[:advanced])
-      rescue ArgumentError => error
-        halt 400, "Advanced parameters invalid: #{error}"
+      # Formats score (a float) to two decimal places.
+      def prettify_score(score)
+        '%.2f' % score
       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']
-
-      # 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
-      if method == 'blastn' and not advanced_opts =~ /task/
-        advanced_opts << ' -task blastn '
+      # 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]
+          s
+        end
       end
+    end
 
-      method    = settings.binaries[ method ]
-      databases = params[:databases].map{|index|
-        settings.databases[index].name
-      }
-      advanced_opts << " -num_threads #{settings.num_threads}"
-
-      # run blast and log
-      blast = Blast.new(method, sequence, databases.join(' '), advanced_opts)
-      blast.run!
-      settings.log.info('Ran: ' + blast.command)
+    # For any request that hits the app in development mode, log incoming
+    # params.
+    before do
+      logger.debug params
+    end
 
-      unless blast.success?
-        halt *blast.error
-      end
+    # Render the search form.
+    get '/' do
+      erb :search, :locals => {:databases => Database.group_by(&:type)}
+    end
 
-      format_blast_results(blast.result, databases)
+    # BLAST search!
+    post '/' do
+      erb :result, :locals => {:report => BLAST.run(params)}
     end
 
-    # get '/get_sequence/?id=sequence_ids&db=retreival_databases'
+    # get '/get_sequence/?sequence_ids=sequence_ids&database_ids=retreival_databases[&download=fasta]'
     #
     # Use whitespace to separate entries in sequence_ids (all other chars exist
     # in identifiers) and retreival_databases (we don't allow whitespace in a
     # database's name, so it's safe).
     get '/get_sequence/' do
-      sequenceids = params[:id].split(/\s/).uniq  # in a multi-blast
-      # query some may have been found multiply
-      retrieval_databases = params[:db].split(/\s/)
-
-      settings.log.info("Looking for: '#{sequenceids.join(', ')}' in '#{retrieval_databases.join(', ')}'")
-
-      # the results do not indicate which database a hit is from.
-      # Thus if several databases were used for blasting, we must check them all
-      # if it works, refactor with "inject" or "collect"?
-      found_sequences     = ''
-
-      retrieval_databases.each do |database|     # we need to populate this session variable from the erb.
-        sequence = sequence_from_blastdb(sequenceids, database)
-        if sequence.empty?
-          settings.log.debug("'#{sequenceids.join(', ')}' not found in #{database}")
-        else
-          found_sequences += sequence
-        end
-      end
-
-      found_sequences_count = found_sequences.count('>')
-
-      out = ''
-      # just in case, checking we found right number of sequences
-      if found_sequences_count != sequenceids.length
-        out <<<<HEADER
-<h1>ERROR: incorrect number of sequences found.</h1>
-<p>Dear user,</p>
+      sequence_ids = params[:sequence_ids].split(/\s/)
+      database_ids = params[:database_ids].split(/\s/)
 
-<p><strong>We have found
-<em>#{found_sequences_count > sequenceids.length ? 'more' : 'less'}</em>
-sequence than expected.</strong></p>
+      sequences = Sequence.from_blastdb(sequence_ids, database_ids)
 
-<p>This is likely due to a problem with how databases are formatted.
-<strong>Please share this text with the person managing this website so
-they can resolve the issue.</strong></p>
-
-<p> You requested #{sequenceids.length} sequence#{sequenceids.length > 1 ? 's' : ''}
-with the following identifiers: <code>#{sequenceids.join(', ')}</code>,
-from the following databases: <code>#{retrieval_databases.join(', ')}</code>.
-But we found #{found_sequences_count} sequence#{found_sequences_count> 1 ? 's' : ''}.
-</p>
-
-<p>If sequences were retrieved, you can find them below (but some may be incorrect, so be careful!).</p>
-<hr/>
-HEADER
-      end
-
-      out << "<pre><code>#{found_sequences}</pre></code>"
-      out
-    end
-
-    # Ensure a '>sequence_identifier\n' at the start of a sequence.
-    #
-    # An empty query line appears in the blast report if the leading
-    # '>sequence_identifier\n' in the sequence is missing. We prepend
-    # the input sequence with user info in such case.
-    #
-    #   > to_fasta("acgt")
-    #   => 'Submitted_By_127.0.0.1_at_110214-15:33:34\nacgt'
-    def to_fasta(sequence)
-      sequence.lstrip!
-      if sequence[0,1] != '>'
-        ip   = request.ip.to_s
-        time = Time.now.strftime("%y%m%d-%H:%M:%S")
-        sequence.insert(0, ">Submitted_By_#{ip}_at_#{time}\n")
-      end
-      return sequence
-    end
-
-    def format_blast_results(result, databases)
-      # Constructing the result in an Array and then calling Array#join is much faster than
-      # building up a String and using +=, as older versions of SeqServ did.
-      formatted_results = []
-
-      @all_retrievable_ids = []
-      string_of_used_databases = databases.join(' ')
-      blast_database_number = 0
-      line_number = 0
-      started_query = false
-      finished_database_summary = false
-      finished_alignments = false
-      reference_string = ''
-      database_summary_string = ''
-      result.each do |line|
-        line_number += 1
-        next if line_number <= 5 #skip the first 5 lines
-
-        # Add the reference to the end, not the start, of the blast result
-        if line_number >= 7 and line_number <= 15
-          reference_string += line
-          next
-        end
-
-        if !finished_database_summary and line_number > 15
-          database_summary_string += line
-          finished_database_summary = true if line.match(/total letters/)
-          next
-        end
-
-        # Remove certain lines from the output
-        skipped_lines = [/^<\/BODY>/,/^<\/HTML>/,/^<\/PRE>/]
-        skip = false
-        skipped_lines.each do |skippy|
-        #  $stderr.puts "`#{line}' matches #{skippy}?"
-          if skippy.match(line)
-            skip = true
-         #   $stderr.puts 'yes'
-          else
-          #  $stderr.puts 'no'
-          end
+      if params[:download]
+        file_name = "sequenceserver_#{sequence_ids.first}.fasta"
+        file = Tempfile.new file_name
+        sequences.each do |sequence|
+          file.puts sequence.fasta
         end
-        next if skip
-
-        # Remove the javascript inclusion
-        line.gsub!(/^<script src=\"blastResult.js\"><\/script>/, '')
-
-        if line.match(/^>/) # If line to possibly replace
-          # Reposition the anchor to the end of the line, so that it both still works and
-          # doesn't interfere with the diagnostic space at the beginning of the line.
-          #
-          # There are two cases:
-          #
-          # database formatted _with_ -parse_seqids
-          line.gsub!(/^>(.+)(<a.*><\/a>)(.*)/, '>\1\3\2')
-          #
-          # database formatted _without_ -parse_seqids
-          line.gsub!(/^>(<a.*><\/a>)(.*)/, '>\2\1')
-
-          # get hit coordinates -- useful for linking to genome browsers
-          hit_length      = result[line_number..-1].index{|l| l =~ />lcl|Lambda/}
-          hit_coordinates = result[line_number, hit_length].grep(/Sbjct/).
-            map(&:split).map{|l| [l[1], l[-1]]}.flatten.map(&:to_i).minmax
-
-          # Create the hyperlink (if required)
-          formatted_results << construct_sequence_hyperlink_line(line, databases, hit_coordinates)
-        else
-          # Surround each query's result in <div> tags so they can be coloured by CSS
-          if matches = line.match(/^<b>Query=<\/b> (.*)/) # If starting a new query, then surround in new <div> tag, and finish the last one off
-            line = "<div class=\"resultn\" id=\"#{matches[1]}\">\n<h3>Query= #{matches[1]}</h3><pre>"
-            unless blast_database_number == 0
-              line = "</pre></div>\n#{line}"
-            end
-            blast_database_number += 1
-          elsif line.match(/^  Database: /) and !finished_alignments
-            formatted_results << "</div>\n<pre>#{database_summary_string}\n\n"
-            finished_alignments = true
-          end
-          formatted_results << line
-        end
-      end
-      formatted_results << "</pre>"
-
-      link_to_fasta_of_all = "/get_sequence/?id=#{@all_retrievable_ids.join(' ')}&db=#{string_of_used_databases}"
-      # #dbs must be sep by ' '
-      retrieval_text       = @all_retrievable_ids.empty? ? '' : "<a href='#{url(link_to_fasta_of_all)}'>FASTA of #{@all_retrievable_ids.length} retrievable hit(s)</a>"
-
-      "<h2>Results</h2>"+
-      retrieval_text +
-      "<br/><br/>" +
-      formatted_results.join +
-      "<br/>" +
-      "<pre>#{reference_string.strip}</pre>"
-    end
-
-    def construct_sequence_hyperlink_line(line, databases, hit_coordinates)
-      matches = line.match(/^>(.+)/)
-      sequence_id = matches[1]
-
-      link = nil
-
-      # If a custom sequence hyperlink method has been defined,
-      # use that.
-      options = {
-        :sequence_id => sequence_id,
-        :databases => databases,
-        :hit_coordinates => hit_coordinates
-      }
-
-      # First precedence: construct the whole line to be customised
-      if self.respond_to?(:construct_custom_sequence_hyperlinking_line)
-        settings.log.debug("Using custom hyperlinking line creator with sequence #{options.inspect}")
-        link_line = construct_custom_sequence_hyperlinking_line(options)
-        unless link_line.nil?
-          return link_line
-        end
-      end
-
-      # If we have reached here, custom construction of the
-      # whole line either wasn't defined, or returned nil
-      # (indicating failure)
-      if self.respond_to?(:construct_custom_sequence_hyperlink)
-        settings.log.debug("Using custom hyperlink creator with sequence #{options.inspect}")
-        link = construct_custom_sequence_hyperlink(options)
-      else
-        settings.log.debug("Using standard hyperlink creator with sequence `#{options.inspect}'")
-        link = construct_standard_sequence_hyperlink(options)
-      end
-
-      # Return the BLAST output line with the link in it
-      if link.nil?
-        settings.log.debug('No link added link for: `'+ sequence_id +'\'')
-        return line
+        file.close
+        send_file file.path, :type => :fasta, :filename => file_name
       else
-        settings.log.debug('Added link for: `'+ sequence_id +'\''+ link)
-        return "><a href='#{url(link)}' target='_blank'>#{sequence_id}</a> \n"
+        {
+          :sequence_ids => sequence_ids,
+          :databases    => Database[database_ids].map(&:title),
+          :sequences    => sequences.map {|s| s.info}
+        }.to_json
       end
+    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}
     end
 
-    # Advanced options are specified by the user. Here they are checked for interference with SequenceServer operations.
-    # raise ArgumentError if an error has occurred, otherwise return without value
-    def validate_advanced_parameters(advanced_options)
-      raise ArgumentError, "Invalid characters detected in the advanced options" unless advanced_options =~ /\A[a-z0-9\-_\. ']*\Z/i
-      disallowed_options = %w(-out -html -outfmt -db -query)
-      disallowed_options.each do |o|
-        raise ArgumentError, "The advanced BLAST option \"#{o}\" is used internally by SequenceServer and so cannot be specified by the you" if advanced_options =~ /#{o}/i
-      end
+    # This will catch any unhandled error and some very special errors. Ideally
+    # we will never hit this block. If we do, there's a bug in SequenceServer
+    # or something really weird going on. If we hit this error block we show
+    # the stacktrace to the user requesting them to post the same to our Google
+    # Group.
+    error Exception, BLAST::RuntimeError do
+      status 500
+      error = env['sinatra.error']
+      erb :'500', :locals => {:error => error}
     end
   end
 end