miga-base 0.2.0.9 → 0.2.1.0

data/actions/daemon

@@ -1,66 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-require "miga/daemon"
-
-task = ARGV.shift unless ["-h","--help"].include? ARGV.first
-ARGV << "-h" if ARGV.empty?
-o = {q:true, update:false, daemon_opts:[]}
-OptionParser.new do |opt|
-   opt.banner = <<BAN
-Controls the daemon of a MiGA project.
-
-Usage: #{$0} #{File.basename(__FILE__)} {task} [options]
-BAN
-   opt.separator "task:"
-   {  start:  "Start an instance of the application.",
-      stop:    "Start an instance of the application.",
-      restart: "Stop all instances and restart them afterwards.",
-      reload:  "Send a SIGHUP to all instances of the application.",
-      run:     "Start the application and stay on top.",
-      zap:     "Set the application to a stopped state.",
-      status:  "Show status (PID) of application instances."
-   }.each{ |k,v| opt.separator sprintf "    %*s%s", -33, k, v }
-   opt.separator ""
-   opt.separator "MiGA options:"
-   opt.on("-P", "--project PATH",
-      "(Mandatory) Path to the project to use."){ |v| o[:project]=v }
-   opt.on("--latency INT",
-      "Number of seconds the daemon will be sleeping."
-      ){ |v| o[:latency]=v.to_i }
-   opt.on("--max-jobs INT",
-      "Maximum number of jobs to use simultaneously."){ |v| o[:maxjobs]=v.to_i }
-   opt.on("--ppn INT",
-      "Maximum number of cores to use in a single job."){ |v| o[:ppn]=v.to_i }
-   opt.on("-v", "--verbose",
-      "Print additional information to STDERR."){ o[:q]=false }
-   opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-      v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-   end
-   opt.on("-h", "--help", "Display this screen.") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-   opt.separator "Daemon options:"
-   opt.on("-t", "--ontop",
-      "Stay on top (does not daemonize)"){ o[:daemon_opts] << '-t' }
-   opt.on("-f", "--force", "Force operation"){ o[:daemon_opts] << '-f' }
-   opt.on("-n", "--no_wait",
-      "Do not wait for processes to stop"){ o[:daemon_opts] << '-n' }
-end.parse!
-
-### MAIN
-raise "Project is mandatory." if o[:project].nil?
-
-raise "Project doesn't exist, aborting." unless
-   MiGA::Project.exist? o[:project]
-p = MiGA::Project.new(o[:project])
-d = MiGA::Daemon.new(p)
-[:latency, :maxjobs, :ppn].each do |k|
-   d.runopts(k, o[k]) unless o[k].nil?
-end
-d.daemon(task, o[:daemon_opts])
-

data/actions/find_datasets

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, add:false, ref:false}
-OptionParser.new do |opt|
-  opt.banner = <<BAN
-Finds unregistered datasets based on result files.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-  opt.separator ""
-  opt.on("-P", "--project PATH",
-    "(Mandatory) Path to the project to use."){ |v| o[:project]=v }
-  opt.on("-a", "--add",
-    "Register the datasets found. By default, only lists them (dry run)."
-    ){ |v| o[:add]=v }
-  opt.on("-t", "--type STRING",
-    "Type of datasets. Recognized types include:",
-    *MiGA::Dataset.KNOWN_TYPES.map{ |k,v| "~ #{k}: #{v[:description]}"}
-    ){ |v| o[:type]=v.to_sym }
-  opt.on("-r", "--ref",
-    "If set, all datasets are registered as reference datasets."
-    ){ |v| o[:ref]=v }
-  opt.on("-u", "--user STRING", "Owner of the dataset."){ |v| o[:user]=v }
-  opt.on("-v", "--verbose",
-    "Print additional information to STDERR."){ o[:q]=false }
-  opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-    v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-  end
-  opt.on("-h", "--help", "Display this screen.") do
-    puts opt
-    exit
-  end
-  opt.separator ""
-end.parse!
-
-
-### MAIN
-raise "-P is mandatory." if o[:project].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Finding datasets." unless o[:q]
-ud = p.unregistered_datasets
-ud.each do |dn|
-  puts dn
-  if o[:add]
-    md = {}
-    [:type, :user].each{ |k| md[k]=o[k] unless o[k].nil? }
-    d = MiGA::Dataset.new(p, dn, o[:ref], md)
-    p.add_dataset(dn)
-    res = d.first_preprocessing
-    puts "- #{res}" unless o[:q]
-  end
-end
-
-$stderr.puts "Done." unless o[:q]

data/actions/import_datasets

@@ -1,83 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, info:false, force:false, method: :hardlink }
-OptionParser.new do |opt|
-   opt.banner = <<BAN
-Link datasets (including results) from one project to another.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-   opt.separator ""
-   opt.on("-P", "--project-source PATH",
-      "(Mandatory) Path to the project that contains the dataset."
-      ){ |v| o[:project1]=v }
-   opt.on("-Q", "--project-target PATH",
-      "(Mandatory) Path to the project where to link the dataset."
-      ){ |v| o[:project2]=v }
-   opt.on("-D", "--dataset STRING",
-      "ID of the dataset to link."){ |v| o[:dataset]=v.miga_name }
-   opt.on("-f", "--force",
-      "Forces linking, even if dataset's preprocessing is incomplete."
-      ){ |v| o[:force]=v }
-   opt.on("-s", "--symlink",
-      "Creates symlinks instead of the default hard links."
-      ){ o[:method] = :symlink }
-   opt.on("-c", "--copy",
-      "Creates copies instead of the default hard links."){ o[:method] = :copy }
-   opt.on("--[no-]ref",
-      "If set, links only reference (or only non-reference) datasets."
-      ){ |v| o[:ref]=v }
-   opt.on("--[no-]multi",
-      "If set, links only multi-species (or only single-species) datasets."
-      ){ |v| o[:multi]=v }
-   opt.on("-t", "--taxonomy RANK:TAXON",
-      "Filter by taxonomy."){ |v| o[:taxonomy]=MiGA::Taxonomy.new v }
-   opt.on("-v", "--verbose",
-      "Print additional information to STDERR."){ o[:q]=false }
-   opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-      v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-   end
-   opt.on("-h", "--help", "Display this screen.") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-end.parse!
-
-
-### MAIN
-raise "-P is mandatory." if o[:project1].nil?
-raise "-Q is mandatory." if o[:project2].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project1])
-raise "Impossible to load project: #{o[:project1]}" if p.nil?
-q = MiGA::Project.load(o[:project2])
-raise "Impossible to load project: #{o[:project2]}" if q.nil?
-
-$stderr.puts "Listing dataset." unless o[:q]
-if o[:dataset].nil?
-   ds = p.datasets
-else
-   ds = [p.dataset(o[:dataset])]
-end
-ds.select!{|d| d.name == o[:dataset]} unless o[:dataset].nil?
-ds.select!{|d| d.is_ref? == o[:ref] } unless o[:ref].nil?
-ds.select! do |d|
-   (not d.metadata[:type].nil?) and
-      (MiGA::Dataset.KNOWN_TYPES[d.metadata[:type]][:multi] == o[:multi])
-end unless o[:multi].nil?
-ds.select! do |d|
-   (not d.metadata[:tax].nil?) and d.metadata[:tax].is_in?(o[:taxonomy])
-end unless o[:taxonomy].nil?
-ds.each do |d|
-   next unless o[:force] or d.done_preprocessing?
-   puts d.name
-   q.import_dataset(d, o[:method])
-end
-
-$stderr.puts "Done." unless o[:q]
-

data/actions/index_taxonomy

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-require "miga/tax_index"
-
-o = {q:true, format: :json}
-OptionParser.new do |opt|
-   opt.banner = <<BAN
-Creates a taxonomy-indexed list of the datasets.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-   opt.separator ""
-   opt.on("-P", "--project PATH",
-      "(Mandatory) Path to the project to read."){ |v| o[:project]=v }
-   opt.on("-i", "--index PATH",
-      "(Mandatory) File to create with the index."){ |v| o[:index]=v }
-   opt.on("-f", "--format STRING",
-      "Format of the index file. By default: #{o[:format]}. Supported: " +
-      "json, tab."){ |v| o[:format]=v.to_sym }
-   opt.on("--[no-]multi",
-      "If set, lists only multi-species (or only single-species) datasets."
-      ){ |v| o[:multi]=v }
-   opt.on("-v", "--verbose",
-      "Print additional information to STDERR."){ o[:q]=false }
-   opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-      v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-   end
-   opt.on("-h", "--help", "Display this screen.") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-end.parse!
-
-### MAIN
-raise "-P is mandatory." if o[:project].nil?
-raise "-i is mandatory." if o[:index].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Loading datasets." unless o[:q]
-ds = p.datasets
-ds.select!{|d| not d.metadata[:tax].nil? }
-ds.select! do |d|
-   (not d.metadata[:type].nil?) and
-      (MiGA::Dataset.KNOWN_TYPES[d.metadata[:type]][:multi] == o[:multi])
-end unless o[:multi].nil?
-
-$stderr.puts "Indexing taxonomy." unless o[:q]
-tax_index = MiGA::TaxIndex.new
-ds.each { |d| tax_index << d }
-
-$stderr.puts "Saving index." unless o[:q]
-fh = File.open(o[:index], "w")
-if o[:format]==:json
-   fh.print tax_index.to_json
-elsif o[:format]==:tab
-   fh.print tax_index.to_tab
-end
-fh.close
-
-$stderr.puts "Done." unless o[:q]
-

data/actions/list_datasets

@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, info:false, processing:false}
-OptionParser.new do |opt|
-  opt.banner = <<BAN
-Lists all registered datasets in an MiGA project.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-  opt.separator ""
-  opt.on("-P", "--project PATH",
-    "(Mandatory) Path to the project to read."){ |v| o[:project]=v }
-  opt.on("-D", "--dataset STRING",
-    "ID of the dataset to read."){ |v| o[:dataset]=v.miga_name }
-  opt.on("--[no-]ref",
-    "If set, lists only reference (or only non-reference) datasets."
-    ){ |v| o[:ref]=v }
-  opt.on("--[no-]multi",
-    "If set, lists only multi-species (or only single-species) datasets."
-    ){ |v| o[:multi]=v }
-  opt.on("-i", "--info",
-    "Print additional information on each dataset."){ |v| o[:info]=v }
-  opt.on("-p", "--processing",
-    "Print information on processing advance."){ |v| o[:processing]=v }
-  opt.on("-t", "--taxonomy RANK:TAXON",
-    "Filter by taxonomy."){ |v| o[:taxonomy]=MiGA::Taxonomy.new v }
-  opt.on("-m", "--metadata STRING",
-    "Print name and metadata field only. If set, ignores -i."
-    ){ |v| o[:datum]=v }
-  opt.on("-v", "--verbose",
-    "Print additional information to STDERR."){ o[:q]=false }
-  opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-    v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-  end
-  opt.on("-h", "--help", "Display this screen.") do
-    puts opt
-    exit
-  end
-  opt.separator ""
-end.parse!
-
-
-### MAIN
-raise "-P is mandatory." if o[:project].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Listing datasets." unless o[:q]
-if o[:dataset].nil?
-  ds = p.datasets
-elsif MiGA::Dataset.exist? p, o[:dataset]
-  ds = [p.dataset(o[:dataset])]
-else
-  ds = []
-end
-ds.select!{|d| d.is_ref? == o[:ref] } unless o[:ref].nil?
-ds.select! do |d|
-  (not d.metadata[:type].nil?) and
-    (MiGA::Dataset.KNOWN_TYPES[d.metadata[:type]][:multi] == o[:multi])
-end unless o[:multi].nil?
-ds.select! do |d|
-  (not d.metadata[:tax].nil?) and d.metadata[:tax].is_in?(o[:taxonomy])
-end unless o[:taxonomy].nil?
-if not o[:datum].nil?
-  ds.each{|d| puts "#{d.name}\t#{d.metadata[ o[:datum] ] || "?"}"}
-elsif o[:info]
-  puts MiGA::MiGA.tabulate(MiGA::Dataset.INFO_FIELDS, ds.map{ |d| d.info })
-elsif o[:processing]
-  comp = ["undef","done","queued"]
-  puts MiGA::MiGA.tabulate([:name] + MiGA::Dataset.PREPROCESSING_TASKS,
-    ds.map{ |d| [d.name] + d.profile_advance.map{ |i| comp[i] } })
-else
-  ds.each{|d| puts d.name}
-end
-
-$stderr.puts "Done." unless o[:q]

data/actions/list_files

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, details:false, json:true}
-OptionParser.new do |opt|
-   opt.banner = <<BAN
-Lists all registered files from the results of a dataset or a project.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-   opt.separator ""
-   opt.on("-P", "--project PATH",
-      "(Mandatory) Path to the project to read."){ |v| o[:project]=v }
-   opt.on("-D", "--dataset STRING",
-      "ID of the dataset to read. If not set, project-wide results are shown."
-      ){ |v| o[:dataset]=v.miga_name }
-   opt.on("-i", "--info",
-      "If set, it prints additional details for each file."
-      ){ |v| o[:details]=v }
-   opt.on("--[no-]json",
-      "If set to no, excludes json files containing results metadata."
-      ){ |v| o[:json]=v }
-   opt.on("-v", "--verbose",
-      "Print additional information to STDERR."){ o[:q]=false }
-   opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-      v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-   end
-   opt.on("-h", "--help", "Display this screen.") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-end.parse!
-
-
-### MAIN
-raise "-P is mandatory." if o[:project].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-if o[:dataset].nil?
-   results = p.results
-else
-   $stderr.puts "Loading dataset." unless o[:q]
-   ds = p.dataset(o[:dataset])
-   raise "Impossible to load dataset: #{o[:dataset]}" if ds.nil?
-   results = ds.results
-end
-
-$stderr.puts "Listing files." unless o[:q]
-results.each do |result|
-   puts "#{ "#{result.path}\t\t" if o[:details] }#{result.path}" if o[:json]
-   result.each_file do |k,f|
-      puts "#{ "#{result.path}\t#{k}\t" if o[:details] }#{result.dir}/#{f}"
-   end
-end
-
-$stderr.puts "Done." unless o[:q]
-

data/actions/unlink_dataset

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, remove:false}
-OptionParser.new do |opt|
-   opt.banner = <<BAN
-Removes a dataset from an MiGA project.
-
-Usage: #{$0} #{File.basename(__FILE__)} [options]
-BAN
-   opt.separator ""
-   opt.on("-P", "--project PATH",
-      "(Mandatory) Path to the project to use."){ |v| o[:project]=v }
-   opt.on("-D", "--dataset PATH",
-      "(Mandatory) ID of the dataset to create."){ |v| o[:dataset]=v }
-   opt.on("-r", "--remove",
-      "Also remove all associated files.",
-      "By default, only unlinks from metadata."){ o[:remove]=true }
-   opt.on("-v", "--verbose",
-      "Print additional information to STDERR."){ o[:q]=false }
-   opt.on("-d", "--debug INT", "Print debugging information to STDERR.") do |v|
-      v.to_i>1 ? MiGA::MiGA.DEBUG_TRACE_ON : MiGA::MiGA.DEBUG_ON
-   end
-   opt.on("-h", "--help", "Display this screen.") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-end.parse!
-
-
-### MAIN
-raise "-P is mandatory." if o[:project].nil?
-raise "-D is mandatory." if o[:dataset].nil?
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Unlinking dataset." unless o[:q]
-raise "Dataset doesn't exist, aborting." unless
-   MiGA::Dataset.exist?(p, o[:dataset])
-d = p.unlink_dataset(o[:dataset])
-d.remove! if o[:remove]
-
-$stderr.puts "Done." unless o[:q]
-