miga-base 0.4.3.0 → 0.5.0.0

data/lib/miga/cli/action/get.rb

@@ -67,66 +67,82 @@ class MiGA::Cli::Action::Get < MiGA::Cli::Action
   end
 
   def perform
-    glob = [cli]
-    unless cli[:file].nil?
-      glob = []
-      File.open(cli[:file], 'r') do |fh|
-        h = nil
-        fh.each do |ln|
-          r = ln.chomp.split(/\t/)
-          if h.nil?
-             h = r
-          else
-            argv_i = [self.name]
-            h.each_with_index do |field, k|
-              case field.downcase
-              when *%w[query ignore-dup get-metadata only-metadata]
-                argv_i << "--#{field.downcase}" if r[k].downcase == 'true'
-              when *%w[project file verbose help debug]
-                raise "Unsupported header: #{field}"
-              else
-                argv_i += ["--#{field.downcase}", r[k]]
-              end
+    glob = get_sub_cli
+    p = cli.load_project
+    glob.each do |sub_cli|
+      rd = create_remote_dataset(sub_cli)
+      next if rd.nil?
+      if sub_cli[:get_md]
+        update_metadata(sub_cli, p, rd)
+      else
+        create_dataset(sub_cli, p, rd)
+      end
+    end
+  end
+
+  private
+
+  def get_sub_cli
+    return [cli] if cli[:file].nil?
+    glob = []
+    File.open(cli[:file], 'r') do |fh|
+      h = nil
+      fh.each do |ln|
+        r = ln.chomp.split(/\t/)
+        if h.nil?
+           h = r
+        else
+          argv_i = [self.name]
+          h.each_with_index do |field, k|
+            case field.downcase
+            when *%w[query ignore-dup get-metadata only-metadata]
+              argv_i << "--#{field.downcase}" if r[k].downcase == 'true'
+            when *%w[project file verbose help debug]
+              raise "Unsupported header: #{field}"
+            else
+              argv_i += ["--#{field.downcase}", r[k]]
             end
-            sub_cli = MiGA::Cli.new(argv_i)
-            sub_cli.defaults = cli.data
-            sub_cli.action.parse_cli
-            glob << sub_cli
           end
+          sub_cli = MiGA::Cli.new(argv_i)
+          sub_cli.defaults = cli.data
+          sub_cli.action.parse_cli
+          glob << sub_cli
         end
       end
     end
+    glob
+  end
 
-    p = cli.load_project
-    glob.each do |sub_cli|
-      sub_cli.ensure_par(dataset: '-D', ids: '-I')
-      unless sub_cli[:api_key].nil?
-        ENV["#{sub_cli[:universe].to_s.upcase}_API_KEY"] = sub_cli[:api_key]
-      end
+  def create_remote_dataset(sub_cli)
+    sub_cli.ensure_par(dataset: '-D', ids: '-I')
+    unless sub_cli[:api_key].nil?
+      ENV["#{sub_cli[:universe].to_s.upcase}_API_KEY"] = sub_cli[:api_key]
+    end
 
-      sub_cli.say "Dataset: #{sub_cli[:dataset]}"
-      if sub_cli[:ignore_dup] && !sub_cli[:get_md]
-        next if Dataset.exist?(p, sub_cli[:dataset])
-      end
+    sub_cli.say "Dataset: #{sub_cli[:dataset]}"
+    if sub_cli[:ignore_dup] && !sub_cli[:get_md]
+      return if Dataset.exist?(p, sub_cli[:dataset])
+    end
 
-      sub_cli.say 'Locating remote dataset'
-      rd = RemoteDataset.new(sub_cli[:ids], sub_cli[:db], sub_cli[:universe])
+    sub_cli.say 'Locating remote dataset'
+    RemoteDataset.new(sub_cli[:ids], sub_cli[:db], sub_cli[:universe])
+  end
 
-      if sub_cli[:get_md]
-        sub_cli.say 'Updating dataset'
-        d = p.dataset(sub_cli[:dataset])
-        next if d.nil?
-        md = sub_cli.add_metadata(d).metadata.data
-        rd.update_metadata(d, md)
-      else
-        sub_cli.say 'Creating dataset'
-        dummy_d = Dataset.new(p, sub_cli[:dataset])
-        md = sub_cli.add_metadata(dummy_d).metadata.data
-        md[:metadata_only] = true if cli[:only_md]
-        dummy_d.remove!
-        rd.save_to(p, sub_cli[:dataset], !sub_cli[:query], md)
-        p.add_dataset(sub_cli[:dataset])
-      end
-    end
+  def update_metadata(sub_cli, p, rd)
+    sub_cli.say 'Updating dataset'
+    d = p.dataset(sub_cli[:dataset])
+    return if d.nil?
+    md = sub_cli.add_metadata(d).metadata.data
+    rd.update_metadata(d, md)
+  end
+
+  def create_dataset(sub_cli, p, rd)
+    sub_cli.say 'Creating dataset'
+    dummy_d = Dataset.new(p, sub_cli[:dataset])
+    md = sub_cli.add_metadata(dummy_d).metadata.data
+    md[:metadata_only] = true if cli[:only_md]
+    dummy_d.remove!
+    rd.save_to(p, sub_cli[:dataset], !sub_cli[:query], md)
+    p.add_dataset(sub_cli[:dataset])
   end
 end

data/lib/miga/cli/action/get_db.rb

@@ -0,0 +1,206 @@
+# @package MiGA
+# @license Artistic-2.0
+
+require 'miga/cli/action'
+require 'net/ftp'
+require 'digest/md5'
+
+class MiGA::Cli::Action::GetDb < MiGA::Cli::Action
+
+  def parse_cli
+    cli.defaults = {
+      database: :recommended,
+      version: :latest,
+      local: File.expand_path('.miga_db', ENV['MIGA_HOME']),
+      host: 'ftp://microbial-genomes.org/db',
+      pb: true,
+      overwrite: true
+    }
+    cli.parse do |opt|
+      opt.on(
+        '-n', '--database STRING',
+        "Name of the database to download. By default: #{cli[:database]}"
+      ) { |v| cli[:database] = v.to_sym }
+      opt.on(
+        '--db-version STRING',
+        "Database version to download. By default: #{cli[:version]}"
+      ) { |v| cli[:version] = v.to_sym }
+      opt.on(
+        '-l', '--local-dir PATH',
+        "Local directory to store the database. By default: #{cli[:local]}"
+      ) { |v| cli[:local] = v }
+      opt.on(
+        '-h', '--host STRING',
+        "Remote host of the database. By default: #{cli[:host]}"
+      ) { |v| cli[:db] = v.to_sym }
+      opt.on(
+        '--list',
+        'List available databases and exit'
+      ) { |v| cli[:list_databases] = v }
+      opt.on(
+        '--list-versions',
+        'List available versions of the database and exit'
+      ) { |v| cli[:list_versions] = v }
+      opt.on(
+        '--no-overwrite',
+        'Exit without downloading if the target database already exists'
+      ) { |v| cli[:overwrite] = v }
+      opt.on('--no-progress', 'Supress progress bars') { |v| cli[:pb] = v }
+    end
+  end
+
+  def perform
+    @ftp = remote_connection
+    manif = remote_manifest(@ftp)
+    cli.puts "# Host: #{manif[:host]}"
+    cli.puts "# Manifest last update: #{manif[:last_update]}"
+    list_databases(manif) and return
+    db = db_requested(manif)
+    list_versions(db) and return
+    ver = version_requested(db)
+    check_target and return
+    file = download_file(@ftp, ver[:path])
+    check_digest(ver, file)
+    unarchive(file)
+    register_database(manif, db, ver)
+  end
+
+  def empty_action
+    cli.puts 'Downloading latest version of the default database'
+  end
+
+  def complete
+    @ftp.close unless @ftp.nil?
+    super
+  end
+
+  private
+
+  def remote_connection
+    cli.say "Connecting to '#{cli[:host]}'"
+    uri = URI.parse(cli[:host])
+    raise 'Only FTP hosts are supported' unless uri.scheme == 'ftp'
+    ftp = Net::FTP.open(uri.host, port: uri.port)
+    ftp.login
+    ftp.chdir(uri.path)
+    ftp
+  end
+
+  def download_file(ftp, path)
+    cli.say "Downloading '#{path}'"
+    Dir.mkdir(cli[:local]) unless Dir.exist? cli[:local]
+    file = File.expand_path(path, cli[:local])
+    filesize = ftp.size(path)
+    transferred = 0
+    ftp.getbinaryfile(path, file, 1024) do |data|
+      if cli[:pb]
+        transferred += data.size
+        cli.advance("#{path}:", transferred, filesize)
+      end
+    end
+    cli.print "\n" if cli[:pb]
+    file
+  end
+
+  def remote_manifest(ftp)
+    file = download_file(ftp, '_manif.json')
+    MiGA::Json.parse(file)
+  end
+
+  def db_requested(manif)
+    [:recommended, :test].each do |n|
+      if cli[:database] == n
+        raise "This host has no #{n} database" if manif[n].nil?
+        cli[:database] = manif[n].to_sym
+      end
+    end
+    db = manif[:databases][cli[:database]]
+    raise 'Cannot find database in this host' if db.nil?
+    db
+  end
+
+  def version_requested(db)
+    if cli[:version] == :latest
+      cli[:version] = db[:latest].to_sym
+    end
+    ver = db[:versions][cli[:version]]
+    raise 'Cannot find database version' if ver.nil?
+    cli.puts "# Database size: #{version_size(ver)}"
+    ver
+  end
+
+  def list_databases(manif)
+    return false unless cli[:list_databases]
+    cli.puts "# Recommended database: #{manif[:recommended]}"
+    cli.puts ''
+    cli.table(
+      %w[name description latest versions],
+      manif[:databases].map do |name, i|
+        [name, i[:description], i[:latest], i[:versions].size.to_s]
+      end
+    )
+    true
+  end
+
+  def list_versions(db)
+    return false unless cli[:list_versions]
+    cli.puts "# Database: #{cli[:database]}"
+    cli.puts ''
+    cli.table(
+      %w[version updated size datasets],
+      db[:versions].map do |name, i|
+        [name, i[:last_update], version_size(i), i[:datasets]]
+      end
+    )
+    true
+  end
+
+  def check_target
+    return false if cli[:overwrite]
+    file = File.expand_path(cli[:database], cli[:local])
+    if Dir.exist? file
+      warn "The target directory already exists: #{file}"
+      true
+    else
+      false
+    end
+  end
+
+  def check_digest(ver, file)
+    cli.say 'Checking MD5 digest'
+    cli.say "Expected: #{ver[:MD5]}"
+    md5 = Digest::MD5.new
+    File.open(file, 'rb') do |fh|
+      until fh.eof?
+        md5.update fh.read(1024)
+      end
+    end
+    dig = md5.hexdigest
+    cli.say "Observed: #{dig}"
+    raise 'Corrupt file, MD5 does not match' unless dig == ver[:MD5]
+  end
+
+  def version_size(ver)
+    cli.num_suffix(ver[:size], true) + ' (' +
+      cli.num_suffix(ver[:size_unarchived], true) + ')'
+  end
+
+  def unarchive(file)
+    cli.say "Unarchiving #{file}"
+    `cd "#{cli[:local]}" && tar -zxf "#{file}"`
+  end
+
+  def register_database(manif, db, ver)
+    cli.say "Registering database locally"
+    local_manif = File.expand_path('_local_manif.json', cli[:local])
+    reg = File.exist?(local_manif) ? MiGA::Json.parse(local_manif) : {}
+    reg[:last_update] = Time.now.to_s
+    reg[:databases] ||= {}
+    reg[:databases][cli[:database]] ||= {}
+    reg[:databases][cli[:database]][:manif_last_update] = manif[:last_update]
+    reg[:databases][cli[:database]][:manif_host] = manif[:host]
+    db.each { |k,v| reg[:databases][cli[:database]][k] = v }
+    reg[:databases][cli[:database]][:local_version] = ver
+    MiGA::Json.generate(reg, local_manif)
+  end
+end

data/lib/miga/cli/action/index_wf.rb

@@ -0,0 +1,31 @@
+# @package MiGA
+# @license Artistic-2.0
+
+require 'miga/cli/action'
+
+class MiGA::Cli::Action::IndexWf < MiGA::Cli::Action
+  require 'miga/cli/action/wf'
+  include MiGA::Cli::Action::Wf
+
+  def parse_cli
+    default_opts_for_wf
+    cli.defaults = { mytaxa: false }
+    cli.parse do |opt|
+      opt.on(
+        '-m', '--mytaxa-scan',
+        'Perform MyTaxa scan analysis'
+      ) { |v| cli[:mytaxa] = v }
+      opts_for_wf_distances(opt)
+      opts_for_wf(opt, 'Input genome assemblies (nucleotides, FastA)',
+        cleanup: false, project_type: true)
+    end
+  end
+
+  def perform
+    # Input data
+    p = create_project(:assembly, {}, run_mytaxa_scan: cli[:mytaxa])
+    # Run
+    run_daemon
+    summarize
+  end
+end

data/lib/miga/cli/action/init.rb

@@ -5,38 +5,39 @@ require 'miga/cli/action'
 require 'shellwords'
 
 class MiGA::Cli::Action::Init < MiGA::Cli::Action
-
+  require 'miga/cli/action/init/daemon_helper'
+  include MiGA::Cli::Action::Init::DaemonHelper
+  
   def parse_cli
     cli.interactive = true
-    cli.defaults = {mytaxa: nil,
+    cli.defaults = { mytaxa: nil,
       config: File.expand_path('.miga_modules', ENV['HOME']),
-      ask: false, auto: false, dtype: :bash}
+      ask: false, auto: false, dtype: :bash }
     cli.parse do |opt|
       opt.on(
         '-c', '--config PATH',
         'Path to the Bash configuration file',
         "By default: #{cli[:config]}"
-        ){ |v| cli[:config] = v }
+      ){ |v| cli[:config] = v }
       opt.on(
         '--[no-]mytaxa',
         'Should I try setting up MyTaxa its dependencies?',
         'By default: interactive (true if --auto)'
-        ){ |v| cli[:mytaxa] = v }
+      ){ |v| cli[:mytaxa] = v }
       opt.on(
         '--daemon-type STRING',
         'Type of daemon launcher, one of: bash, qsub, msub, slurm',
         "By default: interactive (#{cli[:dtype]} if --auto)"
-        ){ |v| cli[:dtype] = v.to_sym }
+      ){ |v| cli[:dtype] = v.to_sym }
       opt.on(
         '--ask-all',
         'Ask for the location of all software',
         'By default, only the locations missing in PATH are requested'
-        ){ |v| cli[:ask] = v }
+      ){ |v| cli[:ask] = v }
     end
   end
 
   def perform
-    miga = MiGA.root_path
     cli.puts <<BANNER
 ===[ Welcome to MiGA, the Microbial Genome Atlas ]===
 
@@ -44,17 +45,70 @@ I'm the initialization script, and I'll sniff around your computer to
 make sure you have all the requirements for MiGA data processing.
 
 BANNER
+    list_requirements
+    rc_fh = open_rc_file
+    check_configuration_script rc_fh
+    paths = check_software_requirements rc_fh
+    check_additional_files paths
+    check_r_packages paths
+    check_ruby_gems paths
+    configure_daemon
+    close_rc_file rc_fh
+    cli.puts 'Configuration complete. MiGA is ready to work!'
+    cli.puts ''
+  end
+
+  def empty_action
+  end
+
+  def run_cmd(cli, cmd)
+    `. "#{cli[:config]}" && #{cmd}`
+  end
+
+  def run_r_cmd(cli, paths, cmd)
+    run_cmd(cli,
+      "echo #{cmd.shellescape} | #{paths['R'].shellescape} --vanilla -q 2>&1")
+  end
+
+  def test_r_package(cli, paths, pkg)
+    run_r_cmd(cli, paths, "library('#{pkg}')")
+    $?.success?
+  end
+
+  def install_r_package(cli, paths, pkg)
+    r_cmd = "install.packages('#{pkg}', repos='http://cran.rstudio.com/')"
+    run_r_cmd(cli, paths, r_cmd)
+  end
 
+  def test_ruby_gem(cli, paths, pkg)
+    run_cmd(cli,
+      "#{paths['ruby'].shellescape} -r #{pkg.shellescape} -e '' 2>/dev/null")
+    $?.success?
+  end
+
+  def install_ruby_gem(cli, paths, pkg)
+    gem_cmd = "Gem::GemRunner.new.run %w(install --user #{pkg})"
+    run_cmd(cli, "#{paths['ruby'].shellescape} \
+        -r rubygems -r rubygems/gem_runner \
+        -e #{gem_cmd.shellescape} 2>&1")
+  end
+
+  def list_requirements
     if cli.ask_user(
           'Would you like to see all the requirements before starting?',
           'no', %w(yes no)) == 'yes'
       cli.puts ''
-      File.open(File.expand_path('utils/requirements.txt', miga), 'r') do |fh|
+      req_path = File.expand_path('utils/requirements.txt', MiGA.root_path)
+      File.open(req_path, 'r') do |fh|
         fh.each_line { |ln| cli.puts ln }
       end
       cli.puts ''
     end
+  end
+
+  private
 
+  def open_rc_file
     rc_path = File.expand_path('.miga_rc', ENV['HOME'])
     if File.exist? rc_path
       if cli.ask_user(
@@ -70,8 +124,10 @@ BANNER
 # `miga init` made this on #{Time.now}
 
 BASH
+    rc_fh
+  end
 
-    # Check bash configuration file
+  def check_configuration_script(rc_fh)
     unless File.exist? cli[:config]
       cli[:config] = cli.ask_user(
             'Is there a script I need to load at startup?',
@@ -86,47 +142,62 @@ BASH
       cli[:config] = '/dev/null'
     end
     cli.puts ''
+  end
 
-    # Check for software requirements
+  def check_software_requirements(rc_fh)
     cli.puts 'Looking for requirements:'
-    if cli[:mytaxa].nil?
-      cli[:mytaxa] = cli.ask_user(
-            'Should I include MyTaxa modules?',
-            'yes', %w(yes no)) == 'yes'
-    end
+    ask_for_mytaxa
     rc_fh.puts 'export MIGA_MYTAXA="no"' unless cli[:mytaxa]
     paths = {}
     rc_fh.puts 'MIGA_PATH=""'
-    File.open(File.expand_path('utils/requirements.txt', miga), 'r') do |fh|
+    req_path = File.expand_path('utils/requirements.txt', MiGA.root_path)
+    File.open(req_path, 'r') do |fh|
       fh.each_line do |ln|
         next if $. < 3
         r = ln.chomp.split(/\t+/)
         next if r[0] =~ /\(opt\)$/ && !cli[:mytaxa]
         cli.print "Testing #{r[0]}#{" (#{r[3]})" if r[3]}... "
-        path = nil
-        loop do
-          d_path = File.dirname(run_cmd(cli, "which #{r[1].shellescape}"))
-          if cli[:ask] || d_path == '.'
-            path = cli.ask_user('Where can I find it?', d_path, nil, true)
-          else
-            path = d_path
-            cli.puts path
-          end
-          if File.executable?(File.expand_path(r[1], path))
-            if d_path != path
-              rc_fh.puts "MIGA_PATH=\"#{path}:$MIGA_PATH\" # #{r[1]}"
-            end
-            break
-          end
-          cli.print "I cannot find #{r[1]} "
-        end
+        path = find_software(r[1])
         paths[r[1]] = File.expand_path(r[1], path).shellescape
       end
     end
     rc_fh.puts 'export PATH="$MIGA_PATH$PATH"'
     cli.puts ''
+    paths
+  end
+
+  def ask_for_mytaxa
+    if cli[:mytaxa].nil?
+      cli[:mytaxa] =
+        cli.ask_user(
+          'Should I include MyTaxa modules?',
+          'yes', %w(yes no)
+        ) == 'yes'
+    end
+  end
+
+  def find_software(exec)
+    path = nil
+    loop do
+      d_path = File.dirname(run_cmd(cli, "which #{exec.shellescape}"))
+      if cli[:ask] || d_path == '.'
+        path = cli.ask_user('Where can I find it?', d_path, nil, true)
+      else
+        path = d_path
+        cli.puts path
+      end
+      if File.executable?(File.expand_path(exec, path))
+        if d_path != path
+          rc_fh.puts "MIGA_PATH=\"#{path}:$MIGA_PATH\" # #{exec}"
+        end
+        break
+      end
+      cli.print "I cannot find #{exec} "
+    end
+    path
+  end
 
-    # Check for other files
+  def check_additional_files(paths)
     if cli[:mytaxa]
       cli.puts 'Looking for MyTaxa databases:'
       mt = File.dirname paths["MyTaxa"]
@@ -145,8 +216,9 @@ BASH
       end
       cli.puts ''
     end
+  end
 
-    # Check for R packages
+  def check_r_packages(paths)
     cli.puts 'Looking for R packages:'
     %w(enveomics.R ape cluster vegan).each do |pkg|
       cli.print "Testing #{pkg}... "
@@ -161,8 +233,9 @@ BASH
       end
     end
     cli.puts ''
+  end
 
-    # Check for Ruby gems
+  def check_ruby_gems(paths)
     cli.puts 'Looking for Ruby gems:'
     %w(sqlite3 daemons json).each do |pkg|
       cli.print "Testing #{pkg}... "
@@ -171,8 +244,8 @@ BASH
       else
         cli.puts 'no, installing'
         # This hackey mess is meant to ensure the test and installation are done
-        # on the configuration Ruby, not on the Ruby currently executing the init
-        # action
+        # on the configuration Ruby, not on the Ruby currently executing the
+        # init action
         cli.print install_ruby_gem(cli, paths, pkg)
         unless test_ruby_gem(cli, paths, pkg)
           raise "Unable to auto-install Ruby gem: #{pkg}"
@@ -180,119 +253,9 @@ BASH
       end
     end
     cli.puts ''
+  end
 
-    # Configure daemon
-    cli.puts 'Default daemon configuration:'
-    daemon_f = File.expand_path('.miga_daemon.json', ENV['HOME'])
-    unless File.exist?(daemon_f) and cli.ask_user(
-              'A template daemon already exists, do you want to preserve it?',
-              'yes', %w(yes no)) == 'yes'
-      v = {created: Time.now.to_s, updated: Time.now.to_s}
-      v[:type] = cli.ask_user(
-        'Please select the type of daemon you want to setup',
-        cli[:dtype], %w(bash qsub msub slurm))
-      case v[:type]
-        when 'bash'
-          v[:latency] = cli.ask_user(
-            'How long should I sleep? (in seconds)', '30').to_i
-          v[:maxjobs] = cli.ask_user(
-            'How many jobs can I launch at once?', '6').to_i
-          v[:ppn]     = cli.ask_user(
-            'How many CPUs can I use per job?', '2').to_i
-          cli.puts 'Setting up internal daemon defaults.'
-          cli.puts 'If you don\'t understand this just leave default values:'
-          v[:cmd]     = cli.ask_user(
-            "How should I launch tasks?\n  %1$s: script path, " \
-              "%2$s: variables, %3$d: CPUs, %4$s: log file, %5$s: task name.\n",
-            "%2$s '%1$s' > '%4$s' 2>&1")
-          v[:var]     = cli.ask_user(
-            "How should I pass variables?\n  %1$s: keys, %2$s: values.\n",
-            "%1$s=%2$s")
-          v[:varsep]  = cli.ask_user(
-            'What should I use to separate variables?', ' ')
-          v[:alive]   = cli.ask_user(
-            "How can I know that a process is still alive?\n  %1$s: PID, " \
-              "output should be 1 for running and 0 for non-running.\n",
-            "ps -p '%1$s'|tail -n+2|wc -l")
-          v[:kill]    = cli.ask_user(
-            "How should I terminate tasks?\n  %s: process ID.", "kill -9 '%s'")
-        when 'slurm'
-          queue       = cli.ask_user(
-            'What queue should I use?', nil, nil, true)
-          v[:latency] = cli.ask_user(
-            'How long should I sleep? (in seconds)', '150').to_i
-          v[:maxjobs] = cli.ask_user(
-            'How many jobs can I launch at once?', '300').to_i
-          v[:ppn]     = cli.ask_user(
-            'How many CPUs can I use per job?', '2').to_i
-          cli.puts 'Setting up internal daemon defaults'
-          cli.puts 'If you don\'t understand this just leave default values:'
-          v[:cmd]     = cli.ask_user(
-            "How should I launch tasks?\n  %1$s: script path, " \
-              "%2$s: variables, %3$d: CPUs, %4$d: log file, %5$s: task name.\n",
-            "%2$s sbatch --partition='#{queue}' --export=ALL " \
-              "--nodes=1 --ntasks-per-node=%3$d --output='%4$s' " \
-              "--job-name='%5$s' --mem=9G --time=12:00:00 %1$s " \
-              "| perl -pe 's/.* //'")
-          v[:var]     = cli.ask_user(
-            "How should I pass variables?\n  %1$s: keys, %2$s: values.\n",
-            "%1$s=%2$s")
-          v[:varsep]  = cli.ask_user(
-            'What should I use to separate variables?', ' ')
-          v[:alive]   = cli.ask_user(
-            "How can I know that a process is still alive?\n  %1$s: job id, " \
-              "output should be 1 for running and 0 for non-running.\n",
-            "squeue -h -o %%t -j '%1$s' | grep '^PD\\|R\\|CF\\|CG$' " \
-              "| tail -n 1 | wc -l")
-          v[:kill]    = cli.ask_user(
-            "How should I terminate tasks?\n  %s: process ID.", "scancel '%s'")
-        else # [qm]sub
-          queue       = cli.ask_user('What queue should I use?', nil, nil, true)
-          v[:latency] = cli.ask_user(
-            'How long should I sleep? (in seconds)', '150').to_i
-          v[:maxjobs] = cli.ask_user(
-            'How many jobs can I launch at once?', '300').to_i
-          v[:ppn]     = cli.ask_user(
-            'How many CPUs can I use per job?', '2').to_i
-          cli.puts 'Setting up internal daemon defaults.'
-          cli.puts 'If you don\'t understand this just leave default values:'
-          v[:cmd]     = cli.ask_user(
-            "How should I launch tasks?\n  %1$s: script path, " \
-              "%2$s: variables, %3$d: CPUs, %4$d: log file, %5$s: task name.\n",
-            "#{v[:type]} -q '#{queue}' -v '%2$s' -l nodes=1:ppn=%3$d %1$s " \
-              "-j oe -o '%4$s' -N '%5$s' -l mem=9g -l walltime=12:00:00 " \
-              "| grep .")
-          v[:var]     = cli.ask_user(
-            "How should I pass variables?\n  %1$s: keys, %2$s: values.\n",
-            "%1$s=%2$s")
-          v[:varsep]  = cli.ask_user(
-            'What should I use to separate variables?', ',')
-          if v[:type] == 'qsub'
-            v[:alive] = cli.ask_user(
-              "How can I know that a process is still alive?\n  " \
-                "%1$s: job id, output should be 1 for running and " \
-                "0 for non-running.\n",
-              "qstat -f '%1$s'|grep ' job_state ='|perl -pe 's/.*= //'" \
-                "|grep '[^C]'|tail -n1|wc -l|awk '{print $1}'")
-            v[:kill]  = cli.ask_user(
-              "How should I terminate tasks?\n  %s: process ID.", "qdel '%s'")
-          else # msub
-            v[:alive] = cli.ask_user(
-              "How can I know that a process is still alive?\n  " \
-                "%1$s: job id, output should be 1 for running and " \
-                "0 for non-running.\n",
-              "checkjob '%1$s'|grep '^State:'|perl -pe 's/.*: //'" \
-                "|grep 'Deferred\\|Hold\\|Idle\\|Starting\\|Running\\|Blocked'" \
-                "|tail -n1|wc -l|awk '{print $1}'")
-            v[:kill]  = cli.ask_user(
-              "How should I terminate tasks?\n  %s: process ID.",
-              "canceljob '%s'")
-          end
-      end
-      File.open(daemon_f, 'w') { |fh| fh.puts JSON.pretty_generate(v) }
-    end
-    cli.puts ''
-
+  def close_rc_file(rc_fh)
     rc_fh.puts <<FOOT
 
 MIGA_CONFIG_VERSION='#{MiGA::MiGA.VERSION}'
@@ -300,44 +263,6 @@ MIGA_CONFIG_LONGVERSION='#{MiGA::MiGA.LONG_VERSION}'
 MIGA_CONFIG_DATE='#{Time.now}'
 
 FOOT
-
-    cli.puts 'Configuration complete. MiGA is ready to work!'
-    cli.puts ''
-
-  end
-
-  def empty_action
-  end
-
-  def run_cmd(cli, cmd)
-    `. "#{cli[:config]}" && #{cmd}`
-  end
-
-  def run_r_cmd(cli, paths, cmd)
-    run_cmd(cli,
-      "echo #{cmd.shellescape} | #{paths['R'].shellescape} --vanilla -q 2>&1")
-  end
-
-  def test_r_package(cli, paths, pkg)
-    run_r_cmd(cli, paths, "library('#{pkg}')")
-    $?.success?
-  end
-
-  def install_r_package(cli, paths, pkg)
-    r_cmd = "install.packages('#{pkg}', repos='http://cran.rstudio.com/')"
-    run_r_cmd(cli, paths, r_cmd)
-  end
-
-  def test_ruby_gem(cli, paths, pkg)
-    run_cmd(cli,
-      "#{paths['ruby'].shellescape} -r #{pkg.shellescape} -e '' 2>/dev/null")
-    $?.success?
-  end
-
-  def install_ruby_gem(cli, paths, pkg)
-    gem_cmd = "Gem::GemRunner.new.run %w(install --user #{pkg})"
-    run_cmd(cli, "#{paths['ruby'].shellescape} \
-        -r rubygems -r rubygems/gem_runner \
-        -e #{gem_cmd.shellescape} 2>&1")
+    rc_fh.close
   end
 end