scbi_distributed_blast 0.0.3

data/History.txt

@@ -0,0 +1,12 @@
+=== 0.0.3 2011-07-07
+
+prerelease
+
+=== 0.0.2 2011-07-06
+
+Initial scbi_distributed_blast
+
+=== 0.0.1 2011-07-06
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,14 @@
+bin/scbi_distributed_blast
+History.txt
+lib/scbi_distributed_blast/scbi_dblast_manager.rb
+lib/scbi_distributed_blast/scbi_dblast_worker.rb
+lib/scbi_distributed_blast.rb
+Manifest.txt
+PostInstall.txt
+Rakefile
+README.rdoc
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_scbi_distributed_blast.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on scbi_distributed_blast, see http://scbi_distributed_blast.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,209 @@
+= scbi_distributed_blast
+
+* http://www.scbi.uma.es/downloads
+
+== DESCRIPTION:
+
+scbi_distributed_blast is a simple distribution mechanism for blast+ made on top of scbi_mapreduce. With scbi_distributed_blast you can perform distributed blasts using a cluster or a set of machines of your network. It uses the version of blast+ that you have installed.
+ 
+== FEATURES:
+
+* Automatically distribute blast+ jobs against multiple computers.
+* Sequences are sent in chunks.
+* scbi_distributed_blast uses scbi_mapreduce and thus is able to exploit all the benefits of a cluster environment. It also works in multi-core machines and big shared-memory servers.
+
+== SYNOPSIS:
+
+Once installed, scbi_distributed_blast is very easy to use. To launch it locally in your own personal computer using 8 cores, you can do:
+  
+  $> scbi_distributed_blast -s 10.0.0 -w 8 'full_blast_cmd'
+  
+Where full_blast_cmd is the blast+ cmd that you would write to execute your desired blast search. Eg.:
+
+  $> scbi_distributed_blast -s 10.0.0 -w 8  'blastn -task blastn-short -db my_db.fasta -query ~/seqs/sample.fasta -outfmt 6 -out output_file'
+
+Sequences are sent in chunks of 100, but you can change this value by using the -g parameter:
+
+  $> scbi_distributed_blast -s 10.0.0 -w 8 -g 200 'blastn -task blastn-short -db my_db.fasta -query ~/seqs/sample.fasta -outfmt 6 -out output_file'
+
+To get additional help:
+
+  $> scbi_distributed_blast -h
+
+=== CLUSTERED EXECUTION:
+
+To take full advantage of a clustered installation, you can launch scbi_distributed_blast in distributed mode. You only need to provide it a list of machine names (or IPs) where workers will be launched (be sure you followed the clustered installation instructions). 
+
+Setup a workers file like this:
+    
+    machine1
+    machine1
+    machine2
+    machine2
+    machine2
+
+And launch scbi_distributed_blast this way:
+
+    $> scbi_distributed_blast -w workers_file -s 10.0.0 'blastn -task blast-short'
+    
+This will launch 2 workers on machine1 and 3 workers on machine2 using the network whose ip starts with 10.0.0 to communicate.
+
+
+== REQUIREMENTS:
+
+* Ruby: 1.9.2 recommended.
+* Blast plus 2.24 or greater (prior versions have bugs that produces bad results)
+
+== REQUIREMENTS INSTALL:
+
+You can skip this section if you have ruby and blast+ already installed.
+
+=== Installing Blast
+
+*Download the latest version of Blast+ from ftp://ftp.ncbi.nlm.nih.gov/blast/executables/release/LATEST/
+*You can also use a precompiled version if you like
+*To install from source, decompress the downloaded file, cd to the decompressed folder, and issue the following commands:
+
+  ./configure
+  make
+  sudo make install
+
+
+=== Installing Ruby 1.9
+
+*You can use RVM to install ruby:
+
+Download latest certificates (maybe you don't need them):
+
+  $ curl -O http://curl.haxx.se/ca/cacert.pem 
+  $ export CURL_CA_BUNDLE=`pwd`/cacert.pem # add this to your .bashrc or 
+equivalent
+
+Install RVM:
+
+  $ bash < <(curl -k https://rvm.beginrescueend.com/install/rvm)
+
+Setup environment:  
+  
+  $ echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bash_profile
+  
+Install ruby 1.9.2 (this can take a while):
+  
+  $ rvm install 1.9.2
+  
+Set it as the default:
+
+  $ rvm use 1.9.2 --default
+
+== INSTALL:
+
+=== Install scbi_distributed_blast
+
+scbi_distributed_blast is very easy to install. It is distributed as a ruby gem:
+
+  gem install scbi_distributed_blast
+  
+This will install scbi_distributed_blast and all the required gems.
+
+
+== CLUSTERED INSTALLATION
+
+To install scbi_distributed_blast into a cluster, you need to have the software available on all machines. By installing it on a shared location, or installing it on each cluster node. Once installed, you need to create a init_file where your environment is correctly setup (paths, BLASTDB, etc). E.g.:
+
+  export PATH=/apps/blast+/bin
+  export BLASTDB=/var/DB/formatted
+  export SCBI_DISTRIBUTED_BLAST_INIT=path_to_init_file
+  
+
+And initialize the SCBI_DISTRIBUTED_BLAST_INIT environment variable on your main node (from where SCBI_DISTRIBUTED_BLAST_INIT will be initially launched):
+
+  source path_to_init_file
+
+If you use any queue system like PBS Pro or Moab/Slurm, be sure to initialize the variables inside each submission script. 
+
+<b>NOTE</b>: all nodes on the cluster should use ssh keys to allow scbi_mapreduce to launch workers without asking for a password.
+
+== SAMPLE INIT FILES FOR CLUSTERED INSTALLATION:
+
+=== Init file
+
+  $> cat ~/scbi_distributed_blast_init_env 
+
+  export BLASTDB=/BLAST_DATABASES/
+  export SCBI_DISTRIBUTED_BLAST_INIT=~/scbi_distributed_blast_init_env
+
+
+=== PBS Submission script
+
+  $> cat sample_work.sh 
+  
+  # 40 distributed workers and 1 GB memory per worker:
+  #PBS -l select=40:ncpus=1:mpiprocs=1:mem=1gb
+  # request 10 hours of walltime:
+  #PBS -l walltime=10:00:00
+  # cd to working directory (from where job was submitted)
+  cd $PBS_O_WORKDIR
+
+  # create workers file with assigned node names
+
+  cat ${PBS_NODEFILE} > workers
+
+  # init scbi_distributed_blast
+  source path_to_init_file
+
+  time scbi_distributed_blast -s 10.0.0 -w workers  'blastn -task blastn-short -db my_db.fasta -query ~/seqs/sample.fasta -outfmt 6 -out output_file'
+
+
+Once this submission script is created, you only need to launch it with:
+
+  qsub sample_work.sh
+
+=== MOAB/SLURM submission script
+
+  $> cat sample_work_moab.sh
+
+  #!/bin/bash 
+  # @ job_name = STN
+  # @ initialdir = .
+  # @ output = STN_%j.out
+  # @ error = STN_%j.err
+  # @ total_tasks = 40
+  # @ wall_clock_limit = 10:00:00
+
+  # guardar lista de workers
+  sl_get_machine_list > workers
+
+  # init scbi_distributed_blast
+  source path_to_init_file
+
+  time scbi_distributed_blast -s 10.0.0 -w workers  'blastn -task blastn-short -db my_db.fasta -query ~/seqs/sample.fasta -outfmt 6 -out output_file'
+
+Then you only need to submit your job with mnsubmit
+
+  mnsubmit sample_work_moab.sh
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Dario Guerrero
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/scbi_distributed_blast'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'scbi_distributed_blast' do
+  self.developer 'Dario Guerrero', 'dariogf@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps           = [['scbi_mapreduce','>= 0.0.33'], ['scbi_blast','>= 0.0.32'],['scbi_fasta','>= 0.1.7']]
+  
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/bin/scbi_distributed_blast

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(File.dirname(__FILE__)),'lib')
+
+# load required libraries
+require 'scbi_mapreduce'
+require 'scbi_distributed_blast'
+require 'logger'
+require 'optparse'
+
+if ENV['SCBI_DISTRIBUTED_BLAST_INIT'] && File.exists?(ENV['SCBI_DISTRIBUTED_BLAST_INIT'])
+  $INIT_FILE=File.expand_path(ENV['SCBI_DISTRIBUTED_BLAST_INIT'])
+elsif File.exists?(File.join('~','scbi_distributed_blast_init_env'))
+  $INIT_FILE=File.join('~','scbi_distributed_blast_init_env')
+else
+  $INIT_FILE=File.join(ROOT_PATH,'scbi_distributed_blast_init_env')
+end
+
+
+options = {}
+
+optparse = OptionParser.new do |opts|
+
+  # Set a banner, displayed at the top
+  # of the help screen.
+  opts.banner = "Usage: #{$0} [options] blast_command"
+
+  # Define the options, and what they do
+  
+  options[:server_ip] = '0.0.0.0'
+  opts.on( '-s', '--server IP', 'Server ip. You can use a partial ip to select the apropriate interface' ) do |server_ip|
+    options[:server_ip] = server_ip
+  end
+
+  options[:port] = 0 # any free port
+  opts.on( '-p', '--port PORT', 'Server port. If set to 0, an arbitrary empty port will be used') do |port|
+    options[:port] = port.to_i
+  end
+
+  # set number of workers. You can also provide an array with worker names.
+  # Those workers names can be read from a file produced by the existing
+  # queue system, if any.
+  options[:workers] = 2
+  opts.on( '-w', '--workers COUNT', 'Number of workers, or file containing machine names to launch workers with ssh' ) do |workers|
+    if File.exists?(workers)
+      # use workers file
+      options[:workers] = File.read(workers).split("\n").map{|w| w.chomp}
+    else
+      begin
+        options[:workers] = Integer(workers)
+      rescue
+        STDERR.puts "ERROR:Invalid workers parameter #{options[:workers]}"
+        exit
+      end
+    end
+  end
+
+  options[:chunk_size] = 100
+  opts.on( '-g', '--group_size chunk_size', 'Group sequences in chunks of size <chunk_size>' ) do |cs|
+    options[:chunk_size] = cs.to_i
+  end
+  
+  options[:log_file] = STDOUT
+  opts.on( '-l', '--log_file file', 'Define a log file. STDOUT by default' ) do |cs|
+    options[:log_file] = cs
+  end
+  
+
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on_tail( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    # show_additional_help
+    exit -1
+  end
+end
+
+# parse options and remove from ARGV
+optparse.parse!
+
+blast_cmd = ARGV.join(' ')
+
+$LOG = Logger.new(options[:log_file])
+$LOG.datetime_format = "%Y-%m-%d %H:%M:%S"
+
+
+$LOG.info "Original Blast+ CMD: #{blast_cmd}"
+
+input_file = nil
+output_file = nil
+
+if blast_cmd.upcase.index('-QUERY')
+  params=blast_cmd.split(' -')
+  params.reverse_each do |param|
+    if param.upcase.index('QUERY ')==0
+      $LOG.debug "found .#{param.strip}."
+      
+      input_file=param.slice(5,param.length).strip
+      input_file=File.expand_path(input_file)
+      params.delete(param)
+      # break
+    end
+
+    if param.upcase.index('OUT ')==0
+      $LOG.debug "found .#{param.strip}."
+      
+      output_file=param.slice(3,param.length).strip
+      output_file=File.expand_path(output_file)
+      params.delete(param)
+      # break
+    end
+      
+      
+  end
+  
+  blast_cmd=params.join(' -')
+end
+
+# puts "BLASTCMD: #{blast_cmd}"
+# puts "Input file: #{input_file}"
+# puts "Output file: #{output_file}"
+
+if !input_file.nil? and File.exists?(File.expand_path(input_file))
+  
+  $LOG.info "Query input file: #{input_file}"
+else
+  $LOG.error "No input file specified in blast command (-query parameter)"
+  exit -1
+end
+
+# we need the path to my_worker in order to launch it when necessary
+# custom_worker_file = File.join(File.dirname(__FILE__),'scbi_dblast_worker.rb')
+custom_worker_file=File.join(File.dirname(File.dirname(__FILE__)),'lib','scbi_distributed_blast','scbi_dblast_worker')
+
+# initialize the work manager. Here you can pass parameters like file names
+ScbiDblastManager.init_work_manager(input_file, blast_cmd, output_file)
+
+# launch processor server
+mgr = ScbiMapreduce::Manager.new(options[:server_ip], options[:port], options[:workers], ScbiDblastManager, custom_worker_file, options[:log_file],$INIT_FILE)
+
+# you can set additional properties
+# =================================
+
+# if you want basic checkpointing. Some performance drop should be expected
+# mgr.checkpointing=true
+
+# if you want to keep the order of input data. Some performance drop should be expected
+# mgr.keep_order=true
+
+# you can set the size of packets of data sent to workers
+mgr.chunk_size=options[:chunk_size]
+
+# start processing
+mgr.start_server
+
+# this line is reached when all data has been processed
+$LOG.info "Program finished"

data/lib/scbi_distributed_blast/scbi_dblast_manager.rb

@@ -0,0 +1,62 @@
+require 'json'
+
+require 'scbi_fasta'
+
+# MyWorkerManager class is used to implement the methods
+# to send and receive the data to or from workers
+class ScbiDblastManager < ScbiMapreduce::WorkManager
+
+  # init_work_manager is executed at the start, prior to any processing.
+  # You can use init_work_manager to initialize global variables, open files, etc...
+  # Note that an instance of MyWorkerManager will be created for each
+  # worker connection, and thus, all global variables here should be
+  # class variables (starting with @@)
+  def self.init_work_manager(input_file, blast_cmd, output_file)
+    @@blast_cmd=blast_cmd
+    if output_file.nil?
+      @@output_file=STDOUT
+    else
+      @@output_file=File.open(output_file,'w')
+    end
+
+    @@fqr = FastaQualFile.new(input_file)
+    
+  end
+
+  # end_work_manager is executed at the end, when all the process is done.
+  # You can use it to close files opened in init_work_manager
+  def self.end_work_manager
+    @@fqr.close
+    @@output_file.close if @@output_file!=STDOUT
+  end
+
+  # worker_initial_config is used to send initial parameters to workers.
+  # The method is executed once per each worker
+  def worker_initial_config
+    {:blast_cmd=>@@blast_cmd}
+  end
+
+  # next_work method is called every time a worker needs a new work
+  # Here you can read data from disk
+  # This method must return the work data or nil if no more data is available
+  def next_work
+    
+    n,f = @@fqr.next_seq
+
+    if n.nil?
+      return nil
+    else
+      return [n,f]
+    end
+
+  end
+
+
+  # work_received is executed each time a worker has finished a job.
+  # Here you can write results down to disk, perform some aggregated statistics, etc...
+  def work_received(results)
+    @@output_file.puts results
+    # write_data_to_disk(results)
+  end
+
+end

data/lib/scbi_distributed_blast/scbi_dblast_worker.rb

@@ -0,0 +1,64 @@
+# MyWorker defines the behaviour of workers.
+# Here is where the real processing takes place
+
+require 'scbi_blast'
+
+class ScbiDblastWorker < ScbiMapreduce::Worker
+
+  # starting_worker method is called one time at initialization
+  # and allows you to initialize your variables
+  def starting_worker
+
+    # You can use worker logs at any time in this way:
+    # $WORKER_LOG.info "Starting a worker"
+
+  end
+
+
+  # receive_initial_config is called only once just after
+  # the first connection, when initial parameters are
+  # received from manager
+  def receive_initial_config(parameters)
+
+    # Reads the parameters
+
+    # You can use worker logs at any time in this way:
+    # $WORKER_LOG.info "Params received"
+
+    # save received parameters, if any
+    @params = parameters
+    
+  end
+
+
+  # process_object method is called for each received object.
+  # Be aware that objs is always an array, and you must iterate
+  # over it if you need to process it independently
+  #
+  # The value returned here will be received by the work_received
+  # method at your worker_manager subclass.
+  def process_object(objs)
+    chunk=[]
+    # iterate over all objects received
+    objs.each do |n,f|
+      chunk<< ">"+n
+      chunk<< f
+      
+      # convert to uppercase
+      # f.downcase!
+    end
+    
+    
+    
+    # puts "Doing blast to #{@params[:blast_cmd]}"
+    blast=BatchBlast.do_blast_cmd(chunk.join("\n"),@params[:blast_cmd])
+    
+    # return objs back to manager
+    return blast
+  end
+
+  # called once, when the worker is about to be closed
+  def closing_worker
+
+  end
+end

data/lib/scbi_distributed_blast.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'scbi_mapreduce'
+require 'scbi_distributed_blast/scbi_dblast_manager.rb'
+
+ROOT_PATH=File.join(File.dirname(__FILE__),'scbi_distributed_blast')
+
+module ScbiDistributedBlast
+   VERSION = '0.0.3'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/scbi_distributed_blast.rb'}"
+puts "Loading scbi_distributed_blast gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/scbi_distributed_blast'

data/test/test_scbi_distributed_blast.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestScbiDistributedBlast < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: scbi_distributed_blast
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Dario Guerrero
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: scbi_mapreduce
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.33
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: scbi_blast
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.32
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: scbi_fasta
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.7
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+  type: :development
+  version_requirements: *id004
+description: scbi_distributed_blast is a simple distribution mechanism for blast+ made on top of scbi_mapreduce. With scbi_distributed_blast you can perform distributed blasts using a cluster or a set of machines of your network. It uses the version of blast+ that you have installed.
+email: 
+- dariogf@gmail.com
+executables: 
+- scbi_distributed_blast
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- bin/scbi_distributed_blast
+- History.txt
+- lib/scbi_distributed_blast/scbi_dblast_manager.rb
+- lib/scbi_distributed_blast/scbi_dblast_worker.rb
+- lib/scbi_distributed_blast.rb
+- Manifest.txt
+- PostInstall.txt
+- Rakefile
+- README.rdoc
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_scbi_distributed_blast.rb
+homepage: http://www.scbi.uma.es/downloads
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: scbi_distributed_blast
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: scbi_distributed_blast is a simple distribution mechanism for blast+ made on top of scbi_mapreduce
+test_files: 
+- test/test_helper.rb
+- test/test_scbi_distributed_blast.rb