miga-base 0.4.3.0 → 0.5.0.0

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

@@ -0,0 +1,124 @@
+# @package MiGA
+# @license Artistic-2.0
+
+##
+# Helper module with daemon configuration functions for MiGA::Cli::Action::Init
+module MiGA::Cli::Action::Init::DaemonHelper
+  def 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 = configure_bash_daemon(v)
+      when 'slurm'
+        v = configure_slurm_daemon(v)
+      else # [qm]sub
+        v = configure_qsub_msub_daemon(v)
+      end
+      File.open(daemon_f, 'w') { |fh| fh.puts JSON.pretty_generate(v) }
+    end
+    cli.puts ''
+  end
+
+  def configure_bash_daemon(v)
+    v[:latency] = cli.ask_user('How long should I sleep? (in secs)', '2').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'")
+    v
+  end
+
+  def configure_slurm_daemon(v)
+    queue       = cli.ask_user('What queue should I use?', nil, nil, true)
+    v[:latency] = cli.ask_user('How long should I sleep? (in secs)', '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'")
+    v
+  end
+
+  def configure_qsub_msub_daemon
+    queue       = cli.ask_user('What queue should I use?', nil, nil, true)
+    v[:latency] = cli.ask_user('How long should I sleep? (in secs)', '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
+    v
+  end
+
+end

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

@@ -6,50 +6,59 @@ require 'miga/cli/action'
 class MiGA::Cli::Action::Ls < MiGA::Cli::Action
 
   def parse_cli
-    cli.defaults = {info: false, processing: false, silent: false}
+    cli.defaults = { info: false, processing: false, silent: false }
     cli.parse do |opt|
       cli.opt_object(opt, [:project, :dataset_opt])
       cli.opt_filter_datasets(opt)
       opt.on(
         '-i', '--info',
         'Print additional information on each dataset'
-        ){ |v| cli[:info] = v }
+      ) { |v| cli[:info] = v }
       opt.on(
         '-p', '--processing',
         'Print information on processing advance'
-        ){ |v| cli[:processing] = v }
+      ) { |v| cli[:processing] = v }
       opt.on(
         '-m', '--metadata STRING',
         'Print name and metadata field only',
         'If set, ignores -i and assumes --tab'
-        ){ |v| cli[:datum] = v }
+      ) { |v| cli[:datum] = v }
       opt.on(
         '--tab',
         'Return a tab-delimited table'
-        ){ |v| cli[:tabular] = v }
+      ) { |v| cli[:tabular] = v }
+      opt.on(
+        '-o', '--output PATH',
+        'Create output file instead of returning to STDOUT'
+      ) { |v| cli[:output] = v }
       opt.on(
         '-s', '--silent',
         'No output and exit with non-zero status if the dataset list is empty'
-        ){ |v| cli[:silent] = v }
+      ) { |v| cli[:silent] = v }
     end
   end
 
   def perform
     ds = cli.load_and_filter_datasets(cli[:silent])
     exit(ds.empty? ? 1 : 0) if cli[:silent]
+    io = cli[:output].nil? ? $stdout : File.open(cli[:output], 'w')
     if !cli[:datum].nil?
       ds.each do |d|
         v = d.metadata[cli[:datum]]
-        puts "#{d.name}\t#{v.nil? ? '?' : v}"
+        cli.puts(io, "#{d.name}\t#{v.nil? ? '?' : v}")
       end
     elsif cli[:info]
-      cli.table(Dataset.INFO_FIELDS, ds.map { |d| d.info })
+      cli.table(Dataset.INFO_FIELDS, ds.map { |d| d.info }, io)
     elsif cli[:processing]
       comp = %w[- done queued]
-      cli.table([:name] + MiGA::Dataset.PREPROCESSING_TASKS,
-        ds.map { |d| [d.name] + d.profile_advance.map { |i| comp[i] } })
+      cli.table(
+        [:name] + MiGA::Dataset.PREPROCESSING_TASKS,
+        ds.map { |d| [d.name] + d.profile_advance.map { |i| comp[i] } },
+        io
+      )
     else
-      ds.each { |d| cli.puts d.name }
+      ds.each { |d| cli.puts(io, d.name) }
     end
+    io.close unless cli[:output].nil?
   end
 end

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

@@ -6,118 +6,202 @@ require 'miga/remote_dataset'
 require 'csv'
 
 class MiGA::Cli::Action::NcbiGet < MiGA::Cli::Action
-
   def parse_cli
-    cli.defaults = {query: false, unlink: false,
+    cli.defaults = {
+      query: false, unlink: false,
       reference: false, legacy_name: false,
       complete: false, chromosome: false,
       scaffold: false, contig: false, add_version: true, dry: false,
-      get_md: false, only_md: false, save_every: 1}
+      get_md: false, only_md: false, save_every: 1
+    }
     cli.parse do |opt|
       cli.opt_object(opt, [:project])
       opt.on(
         '-T', '--taxon STRING',
         '(Mandatory unless --reference) Taxon name (e.g., a species binomial)'
-        ){ |v| cli[:taxon] = v }
-      opt.on('--reference',
-        'Download all reference genomes (ignore any other status)'
-        ){ |v| cli[:reference] = v }
-      opt.on(
-        '--complete',
-        'Download complete genomes'
-        ){ |v| cli[:complete] = v }
-      opt.on('--chromosome',
-        'Download complete chromosomes'
-        ){ |v| cli[:chromosome] = v }
-      opt.on(
-        '--scaffold',
-        'Download genomes in scaffolds'
-        ){ |v| cli[:scaffold] = v }
-      opt.on(
-        '--contig',
-        'Download genomes in contigs'
-        ){ |v| cli[:contig] = v }
-      opt.on(
-        '--all',
-        'Download all genomes (in any status)') do
-          cli[:complete] = true
-          cli[:chromosome] = true
-          cli[:scaffold] = true
-          cli[:contig] = true
-        end
-      opt.on(
-        '--no-version-name',
-        'Do not add sequence version to the dataset name',
-        'Only affects --complete and --chromosome'
-        ){ |v| cli[:add_version] = v }
-      opt.on(
-        '--legacy-name',
-        'Use dataset names based on chromosome entries instead of assembly'
-        ){ |v| cli[:legacy_name] = v }
-      opt.on('--blacklist PATH',
-        'A file with dataset names to blacklist'
-        ){ |v| cli[:blacklist] = v }
-      opt.on(
-        '--dry',
-        'Do not download or save the datasets'
-        ){ |v| cli[:dry] = v }
-      opt.on(
-        '--ignore-until STRING',
-        'Ignores all datasets until a name is found (useful for large reruns)'
-        ){ |v| cli[:ignore_until] = v }
-      opt.on(
-        '--get-metadata',
-        'Only download and update metadata for existing datasets'
-        ){ |v| cli[:get_md] = v }
-      opt.on('--only-metadata',
-        'Create datasets without input data but retrieve all metadata'
-        ){ |v| cli[:only_md] = v }
-      opt.on(
-        '--save-every INT', Integer,
-        'Save project every this many downloaded datasets',
-        'If zero, it saves the project only once upon completion',
-        "By default: #{cli[:save_every]}"
-        ){ |v| cli[:save_every] = v }
+      ) { |v| cli[:taxon] = v }
       opt.on(
-        '-q', '--query',
-        'Register the datasets as queries, not reference datasets'
-        ){ |v| cli[:query] = v }
-      opt.on(
-        '-u', '--unlink',
-        'Unlink all datasets in the project missing from the download list'
-        ){ |v| cli[:unlink] = v }
-      opt.on('-R', '--remote-list PATH',
-        'Path to an output file with the list of all datasets listed remotely'
-        ){ |v| cli[:remote_list] = v }
+        '-m', '--metadata STRING',
+        'Metadata as key-value pairs separated by = and delimited by comma',
+        'Values are saved as strings except for booleans (true / false) or nil'
+      ) { |v| cli[:metadata] = v }
+      cli_task_flags(opt)
+      cli_name_modifiers(opt)
+      cli_filters(opt)
+      cli_save_actions(opt)
       opt.on(
         '--api-key STRING',
         'NCBI API key'
-        ){ |v| ENV['NCBI_API_KEY'] = v }
+      ) { |v| ENV['NCBI_API_KEY'] = v }
     end
   end
 
   def perform
+    sanitize_cli
+    p = cli.load_project
+    ds = remote_list
+    ds = discard_blacklisted(ds)
+    d, downloaded = download_entries(ds, p)
+
+    # Finalize
+    cli.say "Datasets listed: #{d.size}"
+    act = cli[:dry] ? 'to download' : 'downloaded'
+    cli.say "Datasets #{act}: #{downloaded}"
+    unless cli[:remote_list].nil?
+      File.open(cli[:remote_list], 'w') do |fh|
+        d.each { |i| fh.puts i }
+      end
+    end
+    return unless cli[:unlink]
+    unlink = p.dataset_names - d
+    unlink.each { |i| p.unlink_dataset(i).remove! }
+    cli.say "Datasets unlinked: #{unlink.size}"
+  end
+
+  private
+
+  def cli_task_flags(opt)
+    cli.opt_flag(
+      opt, 'reference',
+      'Download all reference genomes (ignore any other status)'
+    )
+    cli.opt_flag(opt, 'complete', 'Download complete genomes')
+    cli.opt_flag(opt, 'chromosome', 'Download complete chromosomes')
+    cli.opt_flag(opt, 'scaffold', 'Download genomes in scaffolds')
+    cli.opt_flag(opt, 'contig', 'Download genomes in contigs')
+    opt.on(
+      '--all',
+      'Download all genomes (in any status)'
+    ) do
+      cli[:complete] = true
+      cli[:chromosome] = true
+      cli[:scaffold] = true
+      cli[:contig] = true
+    end
+  end
+
+  def cli_name_modifiers(opt)
+    opt.on(
+      '--no-version-name',
+      'Do not add sequence version to the dataset name',
+      'Only affects --complete and --chromosome'
+    ) { |v| cli[:add_version] = v }
+    cli.opt_flag(
+      opt, 'legacy-name',
+      'Use dataset names based on chromosome entries instead of assembly',
+      :legacy_name
+    )
+  end
+
+  def cli_filters(opt)
+    opt.on(
+      '--blacklist PATH',
+      'A file with dataset names to blacklist'
+    ) { |v| cli[:blacklist] = v }
+    cli.opt_flag(opt, 'dry', 'Do not download or save the datasets')
+    opt.on(
+      '--ignore-until STRING',
+      'Ignores all datasets until a name is found (useful for large reruns)'
+    ) { |v| cli[:ignore_until] = v }
+    cli.opt_flag(
+      opt, 'get-metadata',
+      'Only download and update metadata for existing datasets', :get_md)
+  end
+
+  def cli_save_actions(opt)
+    cli.opt_flag(
+      opt, 'only-metadata',
+      'Create datasets without input data but retrieve all metadata',
+      :only_md)
+    opt.on(
+      '--save-every INT', Integer,
+      'Save project every this many downloaded datasets',
+      'If zero, it saves the project only once upon completion',
+      "By default: #{cli[:save_every]}"
+    ) { |v| cli[:save_every] = v }
+    opt.on(
+      '-q', '--query',
+      'Register the datasets as queries, not reference datasets'
+    ) { |v| cli[:query] = v }
+    opt.on(
+      '-u', '--unlink',
+      'Unlink all datasets in the project missing from the download list'
+    ) { |v| cli[:unlink] = v }
+    opt.on(
+      '-R', '--remote-list PATH',
+      'Path to an output file with the list of all datasets listed remotely'
+    ) { |v| cli[:remote_list] = v }
+  end
+
+  def sanitize_cli
     cli.ensure_par(taxon: '-T') unless cli[:reference]
-    unless %w[reference complete chromosome scaffold contig].any?{ |i| cli[i.to_sym] }
+    tasks = %w[reference complete chromosome scaffold contig]
+    unless tasks.any? { |i| cli[i.to_sym] }
       raise 'No action requested: pick at least one type of genome'
     end
     cli[:save_every] = 1 if cli[:dry]
+  end
 
-    p = cli.load_project
-    d = []
+  def remote_list
+    cli.say 'Downloading genome list'
     ds = {}
-    downloaded = 0
+    url = remote_list_url
+    doc = RemoteDataset.download_url(url)
+    CSV.parse(doc, headers: true).each do |r|
+      asm = r['assembly']
+      next if asm.nil? || asm.empty? || asm == '-'
+      next unless r['ftp_path_genbank']
+      rep = remote_row_replicons(r)
+      n = remote_row_name(r, rep, asm)
+
+      # Register for download
+      fna_url = '%s/%s_genomic.fna.gz' %
+        [r['ftp_path_genbank'], File.basename(r['ftp_path_genbank'])]
+      ds[n] = {
+        ids: [fna_url], db: :assembly_gz, universe: :web,
+        md: {
+          type: :genome, ncbi_asm: asm, strain: r['strain']
+        }
+      }
+      ds[n][:md][:ncbi_nuccore] = rep.join(',') unless rep.nil?
+      unless r['release_date'].nil?
+        ds[n][:md][:release_date] = Time.parse(r['release_date']).to_s
+      end
+    end
+    ds
+  end
 
+  def remote_row_replicons(r)
+    return if r['replicons'].nil?
+    r['replicons']
+      .split('; ')
+      .map { |i| i.gsub(/.*:/, '') }
+      .map { |i| i.gsub(%r{/.*}, '') }
+  end
+
+  def remote_row_name(r, rep, asm)
+    return r['#organism'].miga_name if cli[:legacy_name] && cli[:reference]
+    if cli[:legacy_name] && ['Complete', ' Chromosome'].include?(r['level'])
+      acc = rep.nil? ? '' : rep.first
+    else
+      acc = asm
+    end
+    acc.gsub!(/\.\d+\Z/, '') unless cli[:add_version]
+    "#{r['#organism']}_#{acc}".miga_name
+  end
+
+  def remote_list_url
     url_base = 'https://www.ncbi.nlm.nih.gov/genomes/solr2txt.cgi?'
     url_param = {
-      q: '[display()].' +
-        'from(GenomeAssemblies).' +
-        'usingschema(/schema/GenomeAssemblies).' +
-        'matching(tab==["Prokaryotes"] and q=="' + cli[:taxon].tr('"',"'") + '"',
-      fields: 'organism|organism,assembly|assembly,replicons|replicons,' +
-        'level|level,ftp_path_genbank|ftp_path_genbank,release_date|release_date,' +
-        'strain|strain',
-      nolimit: 'on',
+      q: '[display()].' \
+        'from(GenomeAssemblies).' \
+        'usingschema(/schema/GenomeAssemblies).' \
+        'matching(tab==["Prokaryotes"] and q=="' \
+          "#{cli[:taxon].tr('"', "'")}\"",
+      fields: 'organism|organism,assembly|assembly,replicons|replicons,' \
+        'level|level,ftp_path_genbank|ftp_path_genbank,' \
+        'release_date|release_date,strain|strain',
+      nolimit: 'on'
     }
     if cli[:reference]
       url_param[:q] += ' and refseq_category==["representative"]'
@@ -131,95 +215,53 @@ class MiGA::Cli::Action::NcbiGet < MiGA::Cli::Action
       url_param[:q] += ' and level==[' + status + ']'
     end
     url_param[:q] += ')'
-    url = url_base + URI.encode_www_form(url_param)
-    cli.say 'Downloading genome list'
-    lineno = 0
-    doc = RemoteDataset.download_url(url)
-    CSV.parse(doc, headers: true).each do |r|
-      asm = r['assembly']
-      next if asm.nil? or asm.empty? or asm == '-'
-      next unless r['ftp_path_genbank']
-
-      # Get replicons
-      rep = r['replicons'].nil? ? nil : r['replicons'].
-          split('; ').map{ |i| i.gsub(/.*:/,'') }.map{ |i| i.gsub(/\/.*/, '') }
-
-      # Set name
-      if cli[:legacy_name] and cli[:reference]
-        n = r['#organism'].miga_name
-      else
-        if cli[:legacy_name] and ['Complete',' Chromosome'].include? r['level']
-          acc = rep.nil? ? '' : rep.first
-        else
-          acc = asm
-        end
-        acc.gsub!(/\.\d+\Z/, '') unless cli[:add_version]
-        n = "#{r['#organism']}_#{acc}".miga_name
-      end
-
-      # Register for download
-      fna_url = r['ftp_path_genbank'] + '/' +
-        File.basename(r['ftp_path_genbank']) + '_genomic.fna.gz'
-      ds[n] = {
-        ids: [fna_url], db: :assembly_gz, universe: :web,
-        md: {
-          type: :genome, ncbi_asm: asm, strain: r['strain']
-        }
-      }
-      ds[n][:md][:ncbi_nuccore] = rep.join(',') unless rep.nil?
-      ds[n][:md][:release_date] =
-        Time.parse(r['release_date']).to_s unless r['release_date'].nil?
-    end
+    url_base + URI.encode_www_form(url_param)
+  end
 
-    # Discard blacklisted
+  def discard_blacklisted(ds)
     unless cli[:blacklist].nil?
       cli.say "Discarding datasets in #{cli[:blacklist]}"
-      File.readlines(cli[:blacklist]).
-        select{ |i| i !~ /^#/ }.map(&:chomp).each{ |i| ds.delete i }
+      File.readlines(cli[:blacklist])
+          .select { |i| i !~ /^#/ }
+          .map(&:chomp)
+          .each { |i| ds.delete i }
     end
+    ds
+  end
 
-    # Download entries
+  def download_entries(ds, p)
     cli.say "Downloading #{ds.size} " + (ds.size == 1 ? 'entry' : 'entries')
     p.do_not_save = true if cli[:save_every] != 1
     ignore = !cli[:ignore_until].nil?
+    downloaded = 0
+    d = []
     ds.each do |name, body|
       d << name
       cli.puts name
       ignore = false if ignore && name == cli[:ignore_until]
-      next if ignore
-      next if p.dataset(name).nil? == cli[:get_md]
+      next if ignore || p.dataset(name).nil? == cli[:get_md]
       downloaded += 1
-      next if cli[:dry]
-      cli.say '  Locating remote dataset'
-      body[:md][:metadata_only] = true if cli[:only_md]
-      rd = RemoteDataset.new(body[:ids], body[:db], body[:universe])
-      if cli[:get_md]
-        cli.say '  Updating dataset'
-        rd.update_metadata(p.dataset(name), body[:md])
-      else
-        cli.say '  Creating dataset'
-        rd.save_to(p, name, !cli[:query], body[:md])
-        p.add_dataset(name)
+      unless cli[:dry]
+        save_entry(name, body, p)
+        p.save! if cli[:save_every] > 1 && (downloaded % cli[:save_every]).zero?
       end
-      p.save! if cli[:save_every] > 1 and (downloaded % cli[:save_every]) == 0
     end
-
     p.do_not_save = false
     p.save! if cli[:save_every] != 1
+    [d, downloaded]
+  end
 
-    # Finalize
-    cli.say "Datasets listed: #{d.size}"
-    cli.say "Datasets #{cli[:dry] ? 'to download' : 'downloaded'}: " +
-      downloaded.to_s
-    unless cli[:remote_list].nil?
-      File.open(cli[:remote_list], 'w') do |fh|
-        d.each { |i| fh.puts i }
-      end
-    end
-    if cli[:unlink]
-      unlink = p.dataset_names - d
-      unlink.each { |i| p.unlink_dataset(i).remove! }
-      cli.say "Datasets unlinked: #{unlink.size}"
+  def save_entry(name, body, p)
+    cli.say '  Locating remote dataset'
+    body[:md][:metadata_only] = true if cli[:only_md]
+    rd = RemoteDataset.new(body[:ids], body[:db], body[:universe])
+    if cli[:get_md]
+      cli.say '  Updating dataset'
+      rd.update_metadata(p.dataset(name), body[:md])
+    else
+      cli.say '  Creating dataset'
+      rd.save_to(p, name, !cli[:query], body[:md])
+      cli.add_metadata(p.add_dataset(name)).save
     end
   end
 end