datalackeytools 0.3.4

data/bin/datalackey-make

@@ -0,0 +1,1014 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2019-2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require 'optparse'
+require 'yaml'
+require 'tempfile'
+require_relative '../lib/datalackeylib'
+
+$CMDOUT = $stdout
+$USEROUT = $stderr
+$OVERWRITE_ACTION = :replace
+$FOLLOW = 0
+$QUIET = false
+$TERMINATE_DELAY = 5
+# For case when we run datalackey.
+$LACKEY = nil
+$MEMORY = nil
+$DIRECTORY = nil
+$PERMISSIONS = nil
+$ECHO = false
+$RULEFILE = nil
+$TIME = false
+$root_dir = Dir.pwd
+
+parser = OptionParser.new do |opts|
+  opts.summary_indent = '  '
+  opts.summary_width = 26
+  opts.banner = 'Usage: datalackey-make [options] targets...'
+  opts.separator ''
+  opts.separator 'Options:'
+  opts.on('-o', '--stdout', 'Use stdout as command output, stderr for user.') do
+    $CMDOUT = $stdout
+    $USEROUT = $stderr
+  end
+  opts.on('-e', '--stderr', 'Use stderr as command output, stdout for user.') do
+    $CMDOUT = $stderr
+    $USEROUT = $stdout
+  end
+  opts.on('-r', '--rules FILE', 'Rule file name to load.') do |f|
+    $RULEFILE = f
+  end
+  opts.on('-q', '--quiet', 'Suppress normal command output.') do
+    $QUIET = true
+  end
+  opts.on('--terminate_delay DELAY', 'Wait DELAY seconds before terminating remaining controller-launched processes, 0 disables.') do |d|
+    $TERMINATE_DELAY = d
+  end
+  opts.on('-h', '--help', 'Print this help and exit.') do
+    $USEROUT.puts opts
+    exit 0
+  end
+  opts.separator 'Options for error checking and tracking execution:'
+  opts.on('--warn', 'Print warning when state is overwritten.') do
+    $OVERWRITE_ACTION = :warn
+  end
+  opts.on('--error', 'State overwriting is an error.') do
+    $OVERWRITE_ACTION = :error
+  end
+  opts.on('-f', '--follow [LEVEL]', Integer, 'Print state/signal/command.') do |level|
+    $FOLLOW = level
+  end
+  opts.on('--time', 'Print state durations.') { $TIME = true }
+end
+
+DatalackeyProcess.options_for_OptionParser(parser, true,
+  proc { |arg| $LACKEY = arg },
+  proc { |arg| $MEMORY = arg },
+  proc { |arg| $DIRECTORY = arg },
+  proc { |arg| $PERMISSIONS = arg },
+  proc { |arg| $ECHO = arg })
+parser.parse!
+
+begin
+  $TERMINATE_DELAY = Float($TERMINATE_DELAY)
+rescue ArgumentError
+  $USEROUT.puts "Terminate delay not a number."
+  exit 1
+end
+if $TERMINATE_DELAY < 0
+  $USEROUT.puts "Terminate delay less than 0."
+  exit 1
+end
+
+if ARGV.empty?
+  $USEROUT.puts "No targets."
+  exit 1
+end
+
+$userout_mutex = Mutex.new
+def userout(message)
+  return false if message.is_a?(Array) && message.empty?
+  message = [ message ] unless message.is_a? Array
+  $userout_mutex.synchronize do
+    message.each { |m| $USEROUT.puts m }
+  end
+  true
+end
+
+def fileline(source, index = nil)
+  if source.is_a? Hash
+    index = source[:load][:index]
+    source = source[:load][:source]
+  end
+  "#{source} : #{index}"
+end
+
+def load_rulefile(filename, current_directory, parent_includes = [])
+  userout("Loading: #{filename} from #{current_directory}") if $FOLLOW > 3
+  begin
+    fullname = File.realpath(filename, current_directory)
+    if parent_includes.include? fullname
+      userout "Include loop: #{filename} from #{current_directory}"
+      return nil
+    end
+    contents = YAML.load(File.read(fullname))
+    directory = File.dirname(fullname)
+  rescue Errno::ENOENT => e
+    userout "Could not find #{filename} from #{current_directory}"
+    return nil
+  rescue StandardError => e
+    userout e.to_s
+    userout "Failed to read #{filename} from #{current_directory}"
+    return nil
+  end
+  unless contents.is_a? Array
+    userout "Not a top level array: #{filename} from #{current_directory}"
+    return nil
+  end
+  rules = []
+  contents.each_index do |index|
+    item = contents[index]
+    begin
+      item.delete 'comment'
+    rescue NoMethodError
+      userout "Item is not a mapping: #{fileline(fullname, index)}"
+      return nil
+    end
+    include_name = item.delete 'include'
+    unless include_name.nil?
+      parent_includes.push fullname
+      included = load_rulefile(include_name, directory, parent_includes)
+      parent_includes.pop
+      if included.nil?
+        userout " .. #{fileline(fullname, index)}"
+        return nil
+      end
+      rules.concat included
+    end
+    cmds = item.delete 'commands'
+    cmds = [ cmds ] if cmds.is_a? String
+    cmds = [] if cmds.nil?
+    cmds.each_index do |k|
+      cmds[k] = cmds[k].split(' ') if cmds[k].is_a? String
+    end
+    common = { :load => { :source => fullname, :index => index } }
+    common[:commands] = cmds
+    # Separate each target/requirements while keeping common parts.
+    item.each_pair do |target, requirements|
+      unless target.is_a? String
+        userout "Target #{target.to_s} is not a string: #{fileline(fullname, index)}"
+        return nil
+      end
+      requirements = [] if requirements.nil?
+      requirements = [ requirements ] if requirements.is_a? String
+      if requirements.is_a? Array
+        requirements.each_index do |n|
+          req = requirements[n]
+          next if req.is_a? String
+          userout "Target #{target} requirement #{req.to_s} is not a string: #{fullname} : #{index}"
+          return nil
+        end
+      else
+        userout "Requirements is not a list: #{fileline(fullname, index)}"
+        return nil
+      end
+      rule = common.clone
+      rule[:commands] = cmds
+      rule[:target] = target
+      rule[:requirements] = requirements
+      rules.push rule
+    end
+  end
+  rules
+end
+
+if $RULEFILE.nil?
+  $RULEFILE = "Rulefile"
+  $root_dir = Dir.pwd
+else
+  $root_dir = File.dirname($RULEFILE)
+  $root_dir = Dir.pwd() if $root_dir == '.'
+  $RULEFILE = File.basename($RULEFILE)
+end
+rules = load_rulefile($RULEFILE, $root_dir)
+exit(2) if rules.nil?
+
+# Overwrite checks. Helper mapping from target to rule to find rules faster.
+target2rule = Hash.new(nil)
+rules.each do |rule|
+  tgt = rule[:target]
+  if target2rule.key? tgt
+    unless $OVERWRITE_ACTION == :replace
+      userout "#{tgt} from #{fileline(target2rule[tgt])} replaced by #{fileline(rule)}"
+      exit(2) if $OVERWRITE_ACTION == :error
+    end
+  end
+  target2rule[tgt] = rule
+end
+
+# Find out the targets we need.
+todo = ARGV.clone
+todo.uniq!
+needed = Hash.new(nil)
+while !todo.empty?
+  tgt = todo.pop
+  next if needed.key? tgt
+  rule = target2rule[tgt]
+  if rule.nil?
+    userout "Unprovided: #{tgt}"
+    exit 2
+  end
+  needed[tgt] = rule
+  rule[:requirements].each do |req|
+    todo.push(req) unless needed.key? req
+  end
+end
+
+def all_needs(rule, needed, full)
+  unless full.include? rule[:target]
+    full.push rule[:target]
+    rule[:requirements].each do |name|
+      next if full.include? name
+      all_needs(needed[name], needed, full)
+    end
+  end
+  return full
+end
+
+needed.each_pair do |target, rule|
+  # Find full set of what this needs.
+  needs = all_needs(rule, needed, [])
+  needs.shift # Name of rule itself is the first item.
+  rule[:needs] = { }
+  needs.each { |name| rule[:needs][name] = nil }
+end
+
+failed = false
+needed.each_pair do |target, rule|
+  needers = []
+  rule[:needs].each_pair do |tgt, r|
+    r = needed[tgt]
+    needers.push(r) if r[:needs].key? target
+  end
+  unless needers.empty?
+    userout "#{fileline(rule)} : #{target} both needs and is needed by:"
+    needers.each do |r|
+      userout "  #{fileline(r)} : #{r[:target]}"
+    end
+    failed = true
+  end
+end
+exit(2) if failed
+
+# Sort so that least needed are first.
+order = needed.values
+def compare(a, b)
+  return -1 if b[:needs].key? a[:target]
+  return 1 if a[:needs].key? b[:target]
+  aidx = ARGV.index(a[:target])
+  bidx = ARGV.index(b[:target])
+  if aidx.nil?
+    if bidx.nil?
+      c = a[:needs].size <=> b[:needs].size
+      return c unless c == 0
+      return a[:commands].size <=> b[:commands].size
+    end
+    return 1
+  else
+    return 1 if bidx.nil?
+    return aidx <=> bidx
+  end
+end
+order.sort! { |a, b| compare(a, b) }
+
+# Final order correctness check.
+fulfilled = Hash.new()
+order.each do |rule|
+  rule[:needs].keys.each do |req|
+    next if fulfilled.key? req
+    userout "#{fileline(rule)} : #{rule[:target]} unfulfilled requirement #{req}"
+    exit 2
+  end
+  fulfilled[rule[:target]] = nil
+end
+
+class Handlers
+  attr_accessor :variables
+
+  def initialize
+    @handlers = Hash.new(nil)
+    @variables = Hash.new(nil)
+    @error_mutex = Mutex.new
+    @error = nil
+    @rule = nil
+  end
+
+  def register(name, object, expand_skip_count = 0)
+    raise ArgumentError, 'Command name is not a string.' unless name.is_a? String
+    @handlers[name] = { object: object, skip: expand_skip_count }
+  end
+
+  def set_error(message)
+    @error_mutex.synchronize { @error = message }
+  end
+
+  def get_binding
+    binding
+  end
+
+  def rule_source
+    @rule.nil? ? nil : @rule.fetch(:load, { }).fetch(:source, nil)
+  end
+
+  def expand(item, info, seen = [])
+    if item.is_a? Array
+      info.push '['
+      result = []
+      item.each { |v| result.push expand(v, info, seen) }
+      info.push ']'
+      return result
+    end
+    if item.is_a? Hash
+      info.push '{'
+      result = { }
+      item.each_pair { |k, v| result[k] = expand(v, info, seen) }
+      info.push '}'
+      return result
+    end
+    info.concat([ ',', item ]) unless info.last == item
+    if item.is_a?(String) && item.start_with?('$') && ENV.key?(item[1...item.size])
+      item = ENV[item[1...item.size]]
+      info.concat [ '=>', item ]
+      return expand(item, info, seen)
+    end
+    if @variables.key? item
+      s = seen.clone
+      s.push item
+      raise "Loop: #{item} via #{s.join(' => ')}." if seen.include? item
+      item = @variables[item]
+      info.concat [ '=>', item ]
+      return expand(item, info, s)
+    end
+    item
+  end
+
+  def run(cmd, rule)
+    @rule = rule
+    @error_mutex.synchronize { return false unless @error.nil? }
+    info = []
+    s_cmd = cmd.to_s
+    userout("Command: #{s_cmd}") if $FOLLOW > 2
+    begin
+      if cmd.is_a? Hash
+        expanded = expand(cmd, info)
+      else
+        handler = @handlers[cmd.first]
+        if handler.nil?
+          expanded = expand(cmd, info)
+        else
+          skip = handler[:skip]
+          skip = cmd.size if cmd.size < skip
+          expanded = cmd[0...skip]
+          rest = cmd[skip...cmd.size]
+          rest = [ rest ] unless rest.is_a? Array
+          expanded.concat expand(rest, info)
+        end
+      end
+    rescue RuntimeError => e
+      userout e.to_s
+      return false
+    end
+    if $FOLLOW > 3
+      s_exp = expanded.to_s
+      userout("Expanded: #{s_exp}") if s_cmd != s_exp
+    end
+    name = nil
+    if expanded.is_a? Hash
+      @handlers.each_key do |key|
+        next unless cmd.key? key # Registered names ought to be unique.
+        name = key
+        break
+      end
+      if name.nil?
+        userout "#{fileline(rule)} : #{rule[:target]} #{cmd.to_s} match for dictionary keys not found."
+        return false
+      end
+    else
+      if expanded.is_a? String
+        name = expanded
+      elsif expanded.is_a? Array
+        name = expanded.first
+      else
+        userout "#{fileline(rule)} : #{rule[:target]} #{cmd.to_s} unexpected type for command: #{expanded.class.name}"
+        return false
+      end
+    end
+    handler = @handlers[name]
+    if handler.nil?
+      userout "#{fileline(rule)} : #{rule[:target]} #{cmd.to_s} unknown command: #{name}"
+      return false
+    end
+    userout("Command: #{name}") if $FOLLOW == 2
+    return false unless handler[:object].handle(expanded)
+    @error_mutex.synchronize { @error.nil? }
+  end
+end
+$handlers = Handlers.new
+
+$terminator = proc do |action, message, vars|
+  case action.first
+  when :error
+    $handlers.set_error(message.join(' '))
+    true
+  when :exitcode
+    $handlers.set_error(message.join(' ')) if vars.first != 0
+    true
+  else false
+  end
+end
+
+# Command handlers.
+
+class Command
+  attr_reader :action
+
+  def initialize(name, expand_skip = 0)
+    $handlers.register(name, self, expand_skip)
+    @name = name
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    $lackey.send(@action, cmd)
+    true
+  end
+
+  def assert(cmd, minlen, maxlen = nil)
+    if cmd.size < minlen
+      userout "Command #{@name} too short: #{cmd.size} < #{minlen}"
+      return false
+    end
+    return true if maxlen.nil?
+    if maxlen < cmd.size
+      userout "Command #{@name} too long: #{maxlen} < #{cmd.size}"
+      return false
+    end
+    true
+  end
+end
+
+class CommentCommand < Command
+  def initialize
+    super('comment', 1000000)
+  end
+
+  def handle(cmd)
+    true
+  end
+end
+CommentCommand.new
+
+class SetCommand < Command
+  def initialize
+    super('set', 2)
+  end
+
+  def handle(cmd)
+    return false unless assert(cmd, 3)
+    $handlers.variables[cmd[1]] = cmd.size == 3 ? cmd[2] : cmd[2...cmd.size]
+    return true
+  end
+end
+SetCommand.new
+
+class DefaultCommand < Command
+  def initialize
+    super('default', 2)
+  end
+
+  def handle(cmd)
+    return false unless assert(cmd, 3)
+    v = cmd[1]
+    unless $handlers.variables.key? v
+      $handlers.variables[v] = cmd.size == 3 ? cmd[2] : cmd[2...cmd.size]
+    end
+    true
+  end
+end
+DefaultCommand.new
+
+class UnsetCommand < Command
+  def initialize
+    super('unset', 1000000)
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd.shift
+    cmd.each { |name| $handlers.variables.delete name }
+    true
+  end
+end
+UnsetCommand.new
+
+class AssertVarCommand < Command
+  def initialize
+    super('assert_var', 1000000)
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd.shift
+    unset = []
+    cmd.each { |name| unset.push(name) unless $handlers.variables.key? name }
+    userout("Not set: #{unset.join(' ')}") unless unset.empty?
+    unset.empty?
+  end
+end
+AssertVarCommand.new
+
+class AssertNotVar < Command
+  def initialize
+    super('assert_notvar', 1000000)
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd.shift
+    set = []
+    cmd.each { |name| set.push(name) if $handlers.variables.key? name }
+    userout("Set: #{set.join(' ')}") unless set.empty?
+    set.empty?
+  end
+end
+AssertNotVar.new
+
+class AssertDataCommand < Command
+  def initialize
+    super('assert_data')
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd.shift
+    data = $lackey.data
+    missing = []
+    cmd.each { |name| missing.push(name) unless data.key? name }
+    userout("Missing: #{missing.join(' ')}") unless missing.empty?
+    missing.empty?
+  end
+end
+AssertDataCommand.new
+
+class RunBase < Command
+  @@actions_run_common = {
+    error: [ 'run', 'error', '*' ],
+    note: {
+      run_error_input_failed: [ 'run', 'error', 'input', 'failed' ],
+      run_child_error_output_format: [
+        [ 'run', 'error', 'format' ], [ 'error', 'format' ] ]
+    },
+    exitcode: [ 'run', 'exit', '?' ],
+    bytes: [ 'run', 'bytes', '?', '*' ]
+  }
+  @@prev_bytes_mutex = Mutex.new
+  @@prev_bytes_id = nil
+
+  def initialize(name)
+    @msgmaker = proc do |action, message, vars|
+      message_maker(action, message, vars)
+    end
+    super(name)
+  end
+
+  def message_maker(action, message, vars)
+    out = []
+    case action.first
+    when :note then
+      case action.last
+      when :run_error_input_failed
+        out.push "Output from #{message[0]} failed."
+        $handlers.set_error message.join(' ')
+      when :run_child_error_output_format
+        out.push "Output to #{message[0]} failed."
+        $handlers.set_error message.join(' ')
+      end
+    when :bytes
+      id = message[0]
+      @@prev_bytes_mutex.synchronize do
+        if id != @@prev_bytes_id
+          out.push "#{id}:"
+          @prev_bytes_id = id
+        end
+      end
+      out.push (vars.map { |c| c.chr }).join
+    end
+    userout(out) unless $QUIET
+    !out.empty?
+  end
+
+  def handle(cmd)
+    return false unless assert(cmd, 4)
+    t = cmd[0] # Swap command and user-given identifier.
+    cmd[0] = cmd[1]
+    cmd[1] = t
+    # Locate executable unless absolute path.
+    idx = cmd.index 'program'
+    unless idx.nil? || idx + 1 == cmd.size
+      cmd[idx + 1] = DatalackeyProcess.locate_executable(cmd[idx + 1],
+        [ Dir.pwd, $root_dir, File.dirname($handlers.rule_source) ])
+    end # Missing program will be found normally and causes error.
+    $lackey.send(@action, cmd, true)
+    true
+  end
+end
+
+class RunCommand < RunBase
+  def initialize
+    super('run')
+    @action = PatternAction.new([
+      { return: [ 'run', 'running', '?' ],
+        error: [ 'run', 'terminated', '?' ]},
+      @@actions_run_common ], [ @msgmaker, $terminator ])
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    super(cmd)
+  end
+end
+RunCommand.new
+
+class ProcessCommand < Command
+  def initialize(name)
+    @action = nil
+    super(name)
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd.concat $lackey.launched.keys if cmd.size == 1
+    return true if cmd.size == 1
+    super(cmd)
+  end
+end
+
+class CloseCommand < ProcessCommand
+  def initialize
+    super('close')
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    cmd[0] = 'end-feed'
+    super(cmd)
+  end
+end
+CloseCommand.new
+
+class TerminateCommand < ProcessCommand
+  def initialize
+    super('terminate')
+  end
+end
+TerminateCommand.new
+
+class FeedCommand < Command
+  def initialize
+    super('feed')
+    @action = PatternAction.new(
+      [ { :error => [ 'error', '*' ] } ],
+      [ $terminator ])
+  end
+end
+FeedCommand.new
+
+class WaitProcessCommand < Command
+  def initialize
+    super('wait_process')
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    return false unless assert(cmd, 2)
+    begin
+      deadline = Time.new + Float(cmd[1])
+    rescue ArgumentError
+      userout "Not a number: #{cmd[1]}"
+      return false
+    end
+    waited = 2 < cmd.size ? $lackey.launched.keys : cmd[2...cmd.size]
+    while (Time.new <=> deadline) == -1
+      sleep(0.2)
+      remains = false
+      current = $lackey.process.keys
+      waited.each { |id| remains ||= current.include? id }
+      return true unless remains
+    end
+  end
+end
+WaitProcessCommand.new
+
+class WaitDataCommand < Command
+  def initialize
+    super('wait_data')
+  end
+
+  def handle(cmd)
+    cmd.flatten!
+    unseen = cmd[1...cmd.size]
+    loop do
+      data = $lackey.data
+      unseen.delete_if { |u| data.key? u }
+      return true if unseen.empty?
+      sleep(0.2)
+    end
+  end
+end
+WaitDataCommand.new
+
+class DeleteCommand < Command
+  def initialize
+    super('delete')
+    @action = nil
+  end
+end
+DeleteCommand.new
+
+class RenameCommand < Command
+  def initialize
+    super('rename')
+    @action = nil
+  end
+end
+RenameCommand.new
+
+class PrintCommand < Command
+  def initialize
+    super('print')
+  end
+
+  def handle(cmd)
+    return true if $QUIET
+    # Array containing arrays will be treated as multi-line output.
+    cmd.shift
+    multi = false
+    cmd.each_index do |k|
+      next unless cmd[k].is_a? Array
+      multi = true
+      cmd[k] = cmd[k].flatten.join(' ')
+    end
+    userout cmd.join(multi ? "\n" : ' ')
+    true
+  end
+end
+PrintCommand.new
+
+class ValueCommand < Command
+  def handle_with_map(cmd, map)
+    return true if $QUIET
+    cmd.flatten!
+    cmd.shift
+    out = []
+    cmd.each { |id| out.push "#{id} : #{map.fetch(id, 'NOT FOUND')}" }
+    userout out
+    true
+  end
+end
+
+class SerialCommand < ValueCommand
+  def initialize
+    super('serial')
+  end
+
+  def handle(cmd)
+    handle_with_map(cmd, $lackey.data)
+  end
+end
+SerialCommand.new
+
+class PIDCommand < ValueCommand
+  def initialize
+    super('pid')
+  end
+
+  def handle(cmd)
+    handle_with_map(cmd, $lackey.process)
+  end
+end
+PIDCommand.new
+
+class ShellCommand < Command
+  def initialize
+    @rule = { 'argv' => '*', 'script' => '*', 'stdout' => '?', 'stderr' => '?', '*' => '*' }
+    super('script')
+  end
+
+  def handle(cmd)
+    # Get interpreter and check that it exists.
+    cmd.delete 'comment'
+    argv = cmd.fetch('argv', [])
+    cmd.delete 'argv'
+    script = cmd['script'] # Pre-requisite for getting this far, exists.
+    cmd.delete 'script'
+    vout = cmd.fetch('stdout', nil)
+    cmd.delete 'stdout'
+    verr = cmd.fetch('stderr', nil)
+    cmd.delete 'stderr'
+    vin = cmd.fetch('stdin', nil)
+    cmd.delete 'stdin'
+    if cmd.size != 1
+      userout "Multiple interpreters: #{cmd.keys.sort.join(' ')}"
+      return false
+    end
+    interpreter = cmd.keys.first
+    hashbangargs = cmd[cmd.keys.first]
+    hashbangargs = hashbangargs.join(' ') if hashbangargs.is_a? Array
+    unless File.exist?(interpreter) && File.executable?(interpreter)
+      userout "Not found or not an executable: #{interpreter}"
+      return false
+    end
+    # Write script into a temporary file.
+    temp = Tempfile.new('make', Dir.tmpdir)
+    begin
+      temp.puts "#!#{interpreter} #{hashbangargs}"
+      temp.puts script
+      temp.chmod(0o700)
+      temp.close
+      argv.prepend temp.path
+    rescue StandardError => e
+      userout "Shell script prepare exception:\n#{e}"
+      temp.close!
+      return false
+    end
+    wait = nil
+    stdin = nil
+    rd_out = nil
+    rd_err = nil
+    exitcode = 0
+    begin
+      # Run script with arguments.
+      stdin, stdout, stderr, wait = Open3.popen3(*argv)
+      rd_out = vout.nil? ? DiscardReader.new(stdout) : StoringReader.new(stdout)
+      rd_err = verr.nil? ? DiscardReader.new(stderr) : StoringReader.new(stderr)
+      stdin.puts(vin) unless vin.nil?
+      stdin.close
+      wait.join
+      $handlers.variables[vout] = rd_out.getlines.join("\n") unless vout.nil?
+      $handlers.variables[verr] = rd_err.getlines.join("\n") unless verr.nil?
+      exitcode = wait.value.exitstatus
+      wait = nil
+      userout("Shell exit: #{exitcode}") if exitcode != 0
+    rescue StandardError => e
+      userout "Shell run exception:\n#{e}"
+      return false
+    ensure
+      stdin.close unless stdin.nil?
+      rd_out.close unless rd_out.nil?
+      rd_err.close unless rd_err.nil?
+      wait.join unless wait.nil?
+      temp.close!
+    end
+    exitcode.zero?
+  end
+end
+ShellCommand.new
+
+class RubyCommand < Command
+  def initialize
+    super('ruby')
+  end
+
+  def handle(cmd)
+    # Access to variables via @variables in binding.
+    script = cmd['ruby']
+    script = script.join("\n") if script.is_a? Array
+    begin
+      eval(script, $handlers.get_binding)
+    rescue StandardError => e
+      userout "Eval failed: #{e}"
+      return false
+    end
+    true
+  end
+end
+RubyCommand.new
+
+
+def notification_check(action, message, vars)
+  case action.first
+  when :data_error then $handlers.set_error(message.to_s)
+  when :error then $handlers.set_error(message.to_s)
+  end
+end
+ntf_check = proc { |act, msg, vars| notification_check(act, msg, vars) }
+
+# Check if we actually need to be running datalackey.
+if $LACKEY.nil? && $MEMORY.nil? && $DIRECTORY.nil?
+  # Seemingly running under datalackey.
+  unless $PERMISSIONS.nil?
+    userout 'Cannot give --permissions/-p unless running datalackey.'
+    exit 1
+  end
+  if $stdin.tty?
+    userout 'Not running under datalackey, turning on memory storage.'
+    $MEMORY = true
+  end
+end
+
+if $LACKEY.nil? && $MEMORY.nil? && $DIRECTORY.nil?
+  $lackey_proc = DatalackeyParentProcess.new($CMDOUT, $stdin)
+  $lackey_stderr = DiscardReader.new($lackey_proc.stderr)
+  $lackey = DatalackeyIO.new(
+    $lackey_proc.stdin, $lackey_proc.stdout, ntf_check)
+else
+  begin
+    $DIRECTORY, $PERMISSIONS, $MEMORY =
+      DatalackeyProcess.verify_directory_permissions_memory(
+        $DIRECTORY, $PERMISSIONS, $MEMORY)
+    $lackey_proc = DatalackeyProcess.new(
+      $LACKEY, $DIRECTORY, $PERMISSIONS, $MEMORY)
+  rescue ArgumentError => e
+    userout e.to_s
+    exit 1
+  end
+  $lackey_stderr = StoringReader.new($lackey_proc.stderr)
+  echo = $ECHO ? proc { |json| userout json } : nil
+  $lackey = DatalackeyIO.new(
+    $lackey_proc.stdin, $lackey_proc.stdout, ntf_check, echo, echo)
+end
+
+# Perform all computations in given order.
+failed = false
+time = Time.new
+order.each do |rule|
+  failed = $lackey.closed?
+  userout("Rule: #{rule[:target]}") if $FOLLOW > 0
+  rule[:commands].each do |cmd|
+    userout $lackey_stderr.getlines
+    next if $handlers.run(cmd, rule)
+    userout "#{fileline(rule)} : #{rule[:target]} command failed: #{cmd}"
+    failed = true
+    break
+  end
+  break if failed
+  next unless $TIME
+  t = time
+  time = Time.new
+  userout "Elapsed #{(time - t).round(2)} s"
+end
+
+unless $lackey.closed?
+  endfeed = [ nil, 'end-feed' ]
+  endfeed.concat $lackey.launched.keys
+  $lackey.send(nil, endfeed, true) if endfeed.size > 2
+end
+terminate_time = Time.new + $TERMINATE_DELAY
+until $lackey.closed?
+  sleep(0.1)
+  procs = $lackey.launched.keys
+  break if procs.empty?
+  next if (Time.new <=> terminate_time) == -1
+  terminate = [ nil, 'terminate' ]
+  terminate.concat procs
+  $lackey.send(nil, terminate, true) if terminate.size > 2
+  break
+end
+
+$lackey_proc.finish
+$lackey.close
+if $LACKEY.nil? && $MEMORY.nil? && $DIRECTORY.nil?
+  $lackey_proc.stdout.close
+  $stderr.close
+end
+$lackey.finish
+$lackey_stderr.close
+userout $lackey_stderr.getlines
+if !$lackey_proc.exit_code.zero? && !$lackey_proc.exit_code.nil?
+  userout("datalackey exit: #{$lackey_proc.exit_code}")
+end
+exit failed ? 1 : 0
+
+# Rulefile:
+#---
+#- target-name: # Multiple target names allowed.
+#  - list
+#  - of
+#  - requirements # Are target names elsewhere. Need to succeed before commands.
+#  commands: # Fixed name for the commands part.
+#  - list
+#  - of
+#  - commands # And if all pass then target has been fulfilled.
+#  comment: # Ignored.
+#  include: # a file name to include.
+#- list: # map to nothing to indicate no requirements.
+#  commands:
+#  - command-list
+#- of: # etc...
+#  - reqs-list
+#  commands: # yadayada...
+#- requirements: # No commands and no requirements.