miga-base 0.5.4.0 → 0.5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7b5a581810fbc79f9808fea7353882960f26f005ff9cc37ccad7483db96f1a4
-  data.tar.gz: dc4d7163c3b6a396e0ca71325d2cb995001b65a467305c918bfc810e161ddae7
+  metadata.gz: 59649a6c1b7aaa4e3c0db090a828469e9595eba42d311eff114417741a2816bd
+  data.tar.gz: a765a214e5b64d3f1758ae50942dc7f0649f438e8c2b12312648012d9cceeacc
 SHA512:
-  metadata.gz: 71e0e8fa7a6e10ac0396a7e19580e66cd8561979234ffb565c0727e02e9050fd04b94c416d56ce35c8b4c618eeb69fb781d52914df26182c01a295b8481cfad9
-  data.tar.gz: 359ad12300c7a1aa14b3f66a2bef2d875c24ea689ab66f1f16990f35618ec03b3126f849039ffcb5ef0a0f52c328eaa5e81edf0bc862aa78104652a9cf73216a
+  metadata.gz: f76b1691a30d7ce94314a4bd8d22601d86d3101c2db33f262b53548bba817d17bc783f2c93ec0502844adda1f5a17bd0c530e82c82c7fb590f07abf8ffc6788c
+  data.tar.gz: c27cd47089f65633cefaca74cd217967b583df43d60682dce9f755a6610fdc6e728638d8d7b884f4de627de79b48080c8325f7b4d60794253f69511c15f997a4

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

@@ -36,6 +36,10 @@ class MiGA::Cli::Action::Daemon < MiGA::Cli::Action
         '--max-jobs INT',
         'Maximum number of jobs to use simultaneously'
       ) { |v| cli[:maxjobs] = v.to_i }
+      opt.on(
+        '--node-list PATH',
+        'Path to the list of execution hostnames'
+      ) { |v| cli[:nodelist] = v }
       opt.on(
         '--ppn INT',
         'Maximum number of cores to use in a single job'
@@ -70,7 +74,7 @@ class MiGA::Cli::Action::Daemon < MiGA::Cli::Action
   def perform
     p = cli.load_project
     d = MiGA::Daemon.new(p, cli[:json])
-    [:latency, :maxjobs, :ppn, :shutdown_when_done].each do |k|
+    [:latency, :maxjobs, :nodelist, :ppn, :shutdown_when_done].each do |k|
       d.runopts(k, cli[k]) unless cli[k].nil?
     end
     d.daemon(cli.operation, cli[:daemon_opts])

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

@@ -26,7 +26,7 @@ class MiGA::Cli::Action::Init < MiGA::Cli::Action
       ){ |v| cli[:mytaxa] = v }
       opt.on(
         '--daemon-type STRING',
-        'Type of daemon launcher, one of: bash, qsub, msub, slurm',
+        'Type of daemon launcher, one of: bash, ssh, qsub, msub, slurm',
         "By default: interactive (#{cli[:dtype]} if --auto)"
       ){ |v| cli[:dtype] = v.to_sym }
       opt.on(

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

@@ -13,15 +13,18 @@ module MiGA::Cli::Action::Init::DaemonHelper
       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))
+        cli[:dtype], %w(bash ssh qsub msub slurm))
       case v[:type]
       when 'bash'
         v = configure_bash_daemon(v)
+      when 'ssh'
+        v = configure_ssh_daemon(v)
       when 'slurm'
         v = configure_slurm_daemon(v)
       else # [qm]sub
         v = configure_qsub_msub_daemon(v)
       end
+      v[:format_version] = 1
       File.open(daemon_f, 'w') { |fh| fh.puts JSON.pretty_generate(v) }
     end
     cli.puts ''
@@ -34,19 +37,51 @@ module MiGA::Cli::Action::Init::DaemonHelper
     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")
+      "How should I launch tasks?\n" \
+        "  {{variables}}: script, vars, cpus, log, task_name, miga\n ",
+      "{{vars}} {{miga}} run -r '{{script}}' -l '{{log}}' -e")
     v[:var]     = cli.ask_user(
-      "How should I pass variables?\n  %1$s: keys, %2$s: values.\n",
-      "%1$s=%2$s")
+      "How should I pass variables?\n" \
+        "  {{variables}}: key, value\n ",
+      "{{key}}={{value}}")
     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")
+      "How can I know that a process is still alive?\n" \
+        "  Output should be 1 for running and 0 for non-running\n" \
+        "  {{variables}}: pid\n ",
+      "ps -p '{{pid}}' | tail -n +2 | wc -l")
     v[:kill]    = cli.ask_user(
-      "How should I terminate tasks?\n  %s: process ID.", "kill -9 '%s'")
+      "How should I terminate tasks?\n" \
+        "  {{variables}}: pid\n ",
+      "kill -9 '{{pid}}'")
+    v
+  end
+
+  def configure_ssh_daemon(v)
+    v[:latency] = cli.ask_user('How long should I sleep? (in secs)', '3').to_i
+    v[:nodelist] = cli.ask_user(
+      'What environmental variable points to node list?', '$MIGA_NODELIST')
+    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" \
+        "  {{variables}}: script, vars, cpus, log, task_name, miga, host\n ",
+      "{{vars}} {{miga}} run -r '{{script}}' -l '{{log}}' -R {{host}} -e")
+    v[:var]     = cli.ask_user(
+      "How should I pass variables?\n" \
+        "  {{variables}}: key, value\n ",
+      "{{key}}={{value}}")
+    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" \
+        "  Output should be 1 for running and 0 for non-running\n" \
+        "  {{variables}}: pid\n ",
+      "ps -p '{{pid}}' | tail -n +2 | wc -l")
+    v[:kill]    = cli.ask_user(
+      "How should I terminate tasks?\n" \
+        "  {{variables}}: pid\n ",
+      "kill -9 '{{pid}}'")
     v
   end
 
@@ -58,24 +93,28 @@ module MiGA::Cli::Action::Init::DaemonHelper
     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 " \
+      "How should I launch tasks?\n" \
+        "  {{variables}}: script, vars, cpus, log, task_name, miga\n ",
+      "{{vars}} sbatch --partition='#{queue}' --export=ALL " \
+        "--nodes=1 --ntasks-per-node={{cpus}} --output='{{log}}' " \
+        "--job-name='{{task_name}}' --mem=9G --time=12:00:00 {{script}} " \
         "| 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")
+      "How should I pass variables?\n" \
+        "  {{variables}}: key, value\n ",
+      "{{key}}={{value}}")
     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$' " \
+      "How can I know that a process is still alive?\n" \
+        "  Output should be 1 for running and 0 for non-running\n" \
+        "  {{variables}}: pid\n ",
+      "squeue -h -o %t -j '{{pid}}' | 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'")
+      "How should I terminate tasks?\n" \
+        "  {{variables}}: pid\n ",
+        "scancel '{{pid}}'")
     v
   end
 
@@ -87,36 +126,40 @@ module MiGA::Cli::Action::Init::DaemonHelper
     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 .")
+      "How should I launch tasks?\n" \
+        "  {{variables}}: script, vars, cpus, log, task_name\n ",
+      "#{v[:type]} -q '#{queue}' -v '{{vars}}' -l nodes=1:ppn={{cpus}} " \
+        "{{script}} -j oe -o '{{log}}' -N '{{task_name}}' -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")
+      "How should I pass variables?\n" \
+        "  {{variables}}: key, value\n ",
+      "{{key}}={{value}}")
     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}'")
+        "How can I know that a process is still alive?\n" \
+          "  Output should be 1 for running and 0 for non-running\n" \
+          "  {{variables}}: pid\n ",
+        "qstat -f '{{pid}}' | grep ' job_state =' | perl -pe 's/.*= //' " \
+          "| grep '[^C]' | tail -n 1 | wc -l | awk '{print $1}'")
       v[:kill]  = cli.ask_user(
-        "How should I terminate tasks?\n  %s: process ID.", "qdel '%s'")
+        "How should I terminate tasks?\n" \
+          "  {{variables}}: pid\n ",
+        "qdel '{{pid}}'")
     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}'")
+        "How can I know that a process is still alive?\n" \
+          "  Output should be 1 for running and 0 for non-running\n" \
+          "  {{variables}}: pid\n ",
+        "checkjob '{{pid}}'|grep '^State:' | perl -pe 's/.*: //' " \
+          "| grep 'Deferred\\|Hold\\|Idle\\|Starting\\|Running\\|Blocked'" \
+          "| tail -n 1 | wc -l | awk '{print $1}'")
       v[:kill]  = cli.ask_user(
-        "How should I terminate tasks?\n  %s: process ID.",
-        "canceljob '%s'")
+        "How should I terminate tasks?\n" \
+          "  {{variables}}: pid\n ",
+        "canceljob '{{pid}}'")
     end
     v
   end

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

@@ -7,7 +7,7 @@ require 'shellwords'
 class MiGA::Cli::Action::Run < MiGA::Cli::Action
 
   def parse_cli
-    cli.defaults = {try_load: false, thr: 1}
+    cli.defaults = { try_load: false, thr: 1, env: false }
     cli.parse do |opt|
       cli.opt_object(opt, [:project, :dataset_opt, :result])
       opt.on(
@@ -23,10 +23,20 @@ class MiGA::Cli::Action::Run < MiGA::Cli::Action
         '-l', '--log PATH',
         'Path to the output log file to be created. If not set, STDOUT'
       ) { |v| cli[:log] = v }
+      opt.on(
+        '-e', '--environment',
+        'Load PROJECT, DATASET, and CORES from the environment'
+      ) { |v| cli[:env] = v }
     end
   end
 
   def perform
+    if cli[:env]
+      cli[:project] ||= ENV['PROJECT']
+      cli[:dataset] ||= ENV['DATASET']
+      cli[:thr] ||= ENV['CORES'].to_i unless ENV['CORES'].nil?
+      cli[:result] = File.basename(cli[:result].to_s, '.bash').to_sym
+    end
     virtual_task = false
     miga = MiGA.root_path
     p = cli.load_project
@@ -43,10 +53,11 @@ class MiGA::Cli::Action::Run < MiGA::Cli::Action
     end
     cmd << MiGA.script_path(cli[:result], miga: miga, project: p).shellescape
     if cli[:remote]
-      cmd.unshift '.', '/etc/profile', ';'
-      cmd = ['ssh', cli[:remote].shellescape, cmd.join(' ').shellescape]
+      #cmd.unshift '.', '/etc/profile', ';'
+      cmd = ['ssh', '-t', '-t', cli[:remote].shellescape,
+        cmd.join(' ').shellescape]
     end
-    cmd << ['&>', cli[:log].shellescape] if cli[:log]
+    cmd << ['>', cli[:log].shellescape, '2>&1'] if cli[:log]
     pid = spawn cmd.join(' ')
     Process.wait pid
   end

data/lib/miga/common/format.rb

@@ -136,4 +136,12 @@ class String
   def wrap_width(width)
     gsub(/([^\n\r]{1,#{width}})/, "\\1\n")
   end
+
+  ##
+  # Replace {{variables}} using the +vars+ hash
+  def miga_variables(vars)
+    o = "#{self}"
+    vars.each { |k, v| o.gsub!("{{#{k}}}", v.to_s) }
+    o
+  end
 end

data/lib/miga/daemon.rb

@@ -42,9 +42,12 @@ class MiGA::Daemon < MiGA::MiGA
   def initialize(project, json = nil)
     $_MIGA_DAEMON_LAIR << self
     @project = project
+    @runopts = {}
     json ||= File.expand_path('daemon/daemon.json', project.path)
-    @runopts = MiGA::Json.parse(
-      json, default: File.expand_path('.miga_daemon.json', ENV['MIGA_HOME']))
+    MiGA::Json.parse(
+      json, default: File.expand_path('.miga_daemon.json', ENV['MIGA_HOME'])
+    ).each { |k,v| runopts(k, v) }
+    update_format_0 unless runopts(:format_version)
     @jobs_to_run = []
     @jobs_running = []
     @loop_i = -1
@@ -145,8 +148,8 @@ class MiGA::Daemon < MiGA::MiGA
   ##
   # Add the task to the internal queue with symbol key +job+. If the task is
   # dataset-specific, +ds+ specifies the dataset. To submit jobs to the
-  # scheduler (or to bash) see #flush!.
-  def queue_job(job, ds=nil)
+  # scheduler (or to bash or ssh) see #flush!
+  def queue_job(job, ds = nil)
     return nil unless get_job(job, ds).nil?
     ds_name = (ds.nil? ? 'miga-project' : ds.name)
     say 'Queueing %s:%s' % [ds_name, job]
@@ -160,19 +163,16 @@ class MiGA::Daemon < MiGA::MiGA
     log_dir = File.expand_path("daemon/#{job}", project.path)
     Dir.mkdir(log_dir) unless Dir.exist? log_dir
     task_name = "#{project.metadata[:name][0..9]}:#{job}:#{ds_name}"
-    to_run = {ds: ds, ds_name: ds_name, job: job, task_name: task_name,
-      cmd: sprintf(runopts(:cmd),
-        # 1: script
-        MiGA::MiGA.script_path(job, miga:vars['MIGA'], project:project),
-        # 2: vars
-        vars.keys.map { |k| sprintf(runopts(:var), k, vars[k]) }.
-          join(runopts(:varsep)),
-        # 3: CPUs
-        ppn,
-        # 4: log file
-        File.expand_path("#{ds_name}.log", log_dir),
-        # 5: task name
-        task_name)}
+    to_run = { ds: ds, ds_name: ds_name, job: job, task_name: task_name }
+    to_run[:cmd] = runopts(:cmd).miga_variables(
+      script: MiGA::MiGA.script_path(job, miga:vars['MIGA'], project: project),
+      vars: vars.map { |k, v|
+        runopts(:var).miga_variables(key: k, value: v) }.join(runopts(:varsep)),
+      cpus: ppn,
+      log: File.expand_path("#{ds_name}.log", log_dir),
+      task_name: task_name,
+      miga: File.expand_path('bin/miga', MiGA::MiGA.root_path).shellescape
+    )
     @jobs_to_run << to_run
   end
 
@@ -191,7 +191,7 @@ class MiGA::Daemon < MiGA::MiGA
 
   ##
   # Remove finished jobs from the internal queue and launch as many as
-  # possible respecting #maxjobs.
+  # possible respecting #maxjobs or #nodelist (if set).
   def flush!
     # Check for finished jobs
     @jobs_running.select! do |job|
@@ -209,17 +209,30 @@ class MiGA::Daemon < MiGA::MiGA
     # Avoid single datasets hogging resources
     @jobs_to_run.rotate! rand(jobs_to_run.size)
     # Launch as many +jobs_to_run+ as possible
-    while jobs_running.size < maxjobs
+    while hostk = next_host
       break if jobs_to_run.empty?
-      launch_job @jobs_to_run.shift
+      launch_job(@jobs_to_run.shift, hostk)
     end
   end
 
+  ##
+  # Retrieves the host index of an available node (if any), nil otherwise. If
+  # #nodelist is not set, returns true as long as #maxjobs is not reached
+  def next_host
+    if nodelist.nil?
+      return jobs_running.size < maxjobs
+    end
+    allk = (0 .. nodelist.size-1).to_a
+    busyk = jobs_running.map { |k| k[:hostk] }
+    availk = allk - busyk
+    availk.empty? ? nil : availk.first
+  end
+
   ##
   # Remove dead jobs.
   def purge!
     @jobs_running.select! do |job|
-      `#{sprintf(runopts(:alive), job[:pid])}`.chomp.to_i == 1
+      `#{runopts(:alive).miga_variables(pid: job[:pid])}`.chomp.to_i == 1
     end
   end
 
@@ -270,14 +283,21 @@ class MiGA::Daemon < MiGA::MiGA
 
   private
 
-    def launch_job(job)
+    def launch_job(job, hostk = nil)
       # Execute job
-      if runopts(:type) == 'bash'
+      case runopts(:type)
+      when 'ssh'
+        # Remote job
+        job[:hostk] = hostk
+        job[:cmd] = job[:cmd].miga_variables(host: nodelist[hostk])
+        job[:pid] = spawn job[:cmd]
+        Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
+      when 'bash'
         # Local job
         job[:pid] = spawn job[:cmd]
         Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
       else
-        # Schedule cluster job
+        # Schedule cluster job (qsub, msub, slurm)
         job[:pid] = `#{job[:cmd]}`.chomp
       end
 
@@ -288,7 +308,20 @@ class MiGA::Daemon < MiGA::MiGA
         say "Unsuccessful #{job[:task_name]}, rescheduling"
       else
         @jobs_running << job
-        say "Spawned pid:#{job[:pid]} for #{job[:task_name]}"
+        say "Spawned pid:#{job[:pid]}#{
+              " to #{job[:hostk]}:#{nodelist[job[:hostk]]}" if job[:hostk]
+            } for #{job[:task_name]}"
       end
     end
+
+    def update_format_0
+      say 'Outdated daemon.json format, updating from version 0'
+      {
+        cmd: %w[script vars cpus log task_name],
+        var: %w[key value],
+        alive: %w[pid],
+        kill: %w[pid]
+      }.each { |k,v| runopts(k, sprintf(runopts(k), *v.map{ |i| "{{#{i}}}" })) }
+      runopts(:format_version, 1)
+    end
 end

data/lib/miga/daemon/base.rb

@@ -1,6 +1,7 @@
 
 require 'daemons'
 require 'date'
+require 'shellwords'
 
 class MiGA::Daemon < MiGA::MiGA
 end
@@ -14,10 +15,18 @@ module MiGA::Daemon::Base
   def runopts(k, v = nil, force = false)
     k = k.to_sym
     unless v.nil?
-      if [:latency, :maxjobs, :ppn].include?(k)
+      case k
+      when :latency, :maxjobs, :ppn, :format_version
         v = v.to_i
-      elsif [:shutdown_when_done].include?(k)
+      when :shutdown_when_done
         v = !!v
+      when :nodelist
+        if v =~ /^\$/
+          vv = ENV[v.sub('$','')] or raise "Unset environment variable: #{v}"
+          v = vv
+        end
+        say "Reading node list: #{v}"
+        v = File.readlines(v).map(&:chomp)
       end
       raise "Daemon's #{k} cannot be set to zero." if !force and v == 0
       @runopts[k] = v
@@ -26,32 +35,36 @@ module MiGA::Daemon::Base
   end
 
   ##
-  # Returns Integer indicating the number of seconds to sleep between checks.
+  # Returns Integer indicating the number of seconds to sleep between checks
   def latency() runopts(:latency); end
 
   ##
-  # Returns Integer indicating the maximum number of concurrent jobs to run.
+  # Returns Integer indicating the maximum number of concurrent jobs to run
   def maxjobs() runopts(:maxjobs); end
 
   ##
-  # Returns Integer indicating the number of CPUs per job.
+  # Returns the path to the list of execution hostnames
+  def nodelist() runopts(:nodelist); end
+
+  ##
+  # Returns Integer indicating the number of CPUs per job
   def ppn() runopts(:ppn); end
 
   ##
   # Returns Boolean indicating if the daemon should shutdown when processing is
-  # complete.
+  # complete
   def shutdown_when_done?() !!runopts(:shutdown_when_done); end
 
   ##
-  # Initializes the daemon with +opts+.
+  # Initializes the daemon with +opts+
   def start(opts = []) daemon('start', opts); end
 
   ##
-  # Stops the daemon with +opts+.
+  # Stops the daemon with +opts+
   def stop(opts = []) daemon('stop', opts); end
 
   ##
-  # Restarts the daemon with +opts+.
+  # Restarts the daemon with +opts+
   def restart(opts = []) daemon('restart', opts); end
 
   ##

data/lib/miga/version.rb

@@ -10,7 +10,7 @@ module MiGA
   # - Float representing the major.minor version.
   # - Integer representing gem releases of the current version.
   # - Integer representing minor changes that require new version number.
-  VERSION = [0.5, 4, 0]
+  VERSION = [0.5, 5, 0]
 
   ##
   # Nickname for the current major.minor version.
@@ -18,7 +18,7 @@ module MiGA
 
   ##
   # Date of the current gem release.
-  VERSION_DATE = Date.new(2020, 1, 22)
+  VERSION_DATE = Date.new(2020, 2, 4)
 
   ##
   # Reference of MiGA.

data/test/daemon_test.rb

@@ -9,8 +9,9 @@ class DaemonTest < Test::Unit::TestCase
     ENV["MIGA_HOME"] = $tmp
     FileUtils.touch("#{ENV["MIGA_HOME"]}/.miga_rc")
     File.open("#{ENV["MIGA_HOME"]}/.miga_daemon.json", "w") do |fh|
-      fh.puts '{"maxjobs":1,"ppn":1,"latency":2,"varsep":" ","var":"%s=%s",
-        "cmd":"%5$s","alive":"echo 1 # %s","type":"bash"}'
+      fh.puts '{"maxjobs":1,"ppn":1,"latency":2,"varsep":" ",
+        "var":"{{key}}={{value}}","cmd":"{{task_name}}",
+        "alive":"echo 1 # {{pid}}","type":"bash","format_version":1}'
     end
     $p1 = MiGA::Project.new(File.expand_path("project1", $tmp))
     $d1 = MiGA::Daemon.new($p1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miga-base
 version: !ruby/object:Gem::Version
-  version: 0.5.4.0
+  version: 0.5.5.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-22 00:00:00.000000000 Z
+date: 2020-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons