datalackeytools 0.3.4

data/bin/datalackey-run

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: false
+
+# Copyright © 2019-2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+# Argument handling and checking
+# datalackey process
+# Main loop
+
+require_relative '../lib/common'
+require_relative '../lib/datalackeylib'
+require 'optparse'
+require 'json'
+
+
+# Argument handling and checking
+
+ENV['POSIXLY_CORRECT'] = '1'
+
+class Arguments
+  attr_reader :directory, :memory, :lackey, :permissions, :terminate_delay, :echo
+
+  def initialize
+    @directory = nil
+    @memory = false
+    @lackey = nil
+    @permissions = nil
+    @terminate_delay = nil
+    @echo = false
+  end
+
+  def parse
+    parser = OptionParser.new do |opts|
+      opts.summary_indent = ''
+      opts.summary_width = 28
+      opts.banner = 'Usage: datalackey-run [options] command params'
+      opts.separator ''
+      opts.separator 'Options:'
+      opts.on_tail('--help', 'Print this help and exit.') do
+        puts opts
+        exit 0
+      end
+      opts.on('--terminate_delay DELAY', 'Seconds to let remaining controller-launched processes to exit, 0 disables.') do |d|
+        @terminate_delay = d
+      end
+    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!
+    # Perform sanity checks on the values.
+    begin
+      @directory, @permissions, @memory =
+        DatalackeyProcess.verify_directory_permissions_memory(
+          @directory, @permissions, @memory)
+      if @terminate_delay.nil?
+        @terminate_delay = 5
+      else
+        @terminate_delay = Float(@terminate_delay)
+        aargh('Terminate delay less than 0.', 1) if @terminate_delay.negative?
+      end
+      @echo = @echo ? proc { |json| put_echo json } : nil
+    rescue ArgumentError => e
+      aargh e.to_s, 1
+    end
+  end
+end
+
+def put_echo(json)
+  begin
+    j = JSON.parse(json)
+    if j.is_a?(Array) && j.size > 3 && j[2] == 'bytes'
+      s = ''
+      (3...j.size).each do |k|
+        s += j[k].chr
+      end
+      j.slice!(3, j.size - 3)
+      j.push s
+      json = JSON.generate(j)
+    end
+  rescue StandardError
+  end
+  puts json
+end
+
+arguments = Arguments.new
+arguments.parse
+
+# datalackey process
+begin
+  $lackey_proc = DatalackeyProcess.new(arguments.lackey, arguments.directory, arguments.permissions, arguments.memory)
+rescue ArgumentError => e
+  puts e.to_s
+  exit 1
+end
+$lackey_stderr = StoringReader.new($lackey_proc.stderr)
+$lackey = DatalackeyIO.new($lackey_proc.stdin, $lackey_proc.stdout, nil, arguments.echo, arguments.echo)
+
+run_actions = {
+  return: [ { run_running: [ 'run', 'running', '?' ] } ],
+  error: [
+      [ 'run', 'error', '*' ],
+      [ '?', 'error', 'argument', 'invalid' ],
+      [ '?', 'error', 'argument', 'not-integer' ],
+      [ '?', 'missing', '*' ]
+  ],
+  note: {
+    run_error_input_failed: [ 'run', 'error', 'input', 'failed' ],
+    run_child_error_output_format: [ [ 'run', 'error', 'format' ],
+      [ 'error', 'format' ] ],
+    run_terminated: [ 'run', 'terminated', '?' ],
+    run_exit: [ 'run', 'exit', '?' ],
+    run_signal: [ 'run', 'signal', '?' ],
+    run_stop: [ 'run', 'stopped', '?' ],
+    run_continue: [ 'run', 'continued' ],
+    run_closed: [ 'run', 'input', 'closed' ]
+  },
+  bytes: [ 'run', 'bytes', '?', '*' ]
+}
+
+$output_mutex = Mutex.new
+$output = []
+$quitting = false
+$exit_code = 0
+
+def run_proc(action, message, vars)
+  $output_mutex.synchronize do
+    case action.first
+    when :error
+      $output.push "ERROR: #{message[3...message.length].join(' ')}"
+      $quitting = true
+    when :note
+      case action[1]
+      when :run_error_input_failed
+        $output.push('Input failed.') unless $quitting
+      when :run_child_error_output_format
+        $output.push 'Output format error.'
+      when :run_terminated
+        $output.push 'Terminated.'
+        $quitting = true
+      when :run_exit
+        $exit_code = vars.last
+        $quitting = true
+      when :run_signal then $output.push "Signal: #{vars.first}"
+      when :run_stop then $output.push "Stopped: #{vars.first}"
+      when :run_continue then $output.push 'Continued.'
+      end
+    when :bytes then $output.push ''.concat(*vars)
+    end
+  end
+  false
+end
+
+run_pa = PatternAction.new([ run_actions ],
+  [ proc { |act, msg, vars| run_proc(act, msg, vars) } ])
+
+# Run the program that was given in the command-line.
+cmd = [ "datalackey-run-#{Process.pid}", 'run',
+  'in', 'JSON', 'stdin', 'out', 'JSON', 'stdout', 'out', 'bytes', 'stderr',
+  'notify', 'data', 'notify', 'process', 'program'
+]
+cmd.concat ARGV
+$lackey.send(run_pa, cmd, true)
+
+# Main loop
+
+def get_output
+  unless $quitting
+    $output_mutex.synchronize do
+      result = $output
+      $output = []
+      return result
+    end
+  else
+    result = $output
+    $output = []
+    return result
+  end
+end
+
+def handle_outputs
+  had_output = false
+  get_output.each do |out|
+    had_output = true
+    puts out
+  end
+  return had_output if $quitting
+  $lackey_stderr.getlines.each do |e|
+    had_output = true
+    aargh e
+  end
+  had_output
+end
+
+def id_list_message(command, ids)
+  return if ids.empty?
+  cmd = [ nil, command ] # No need to get replies.
+  cmd.concat ids
+  $lackey.dump(JSON.generate(cmd))
+end
+
+terminate_time = nil
+until $lackey.closed?
+  sleep(0.1) unless handle_outputs
+  next unless $quitting
+  # Here controller has exited.
+  handle_outputs # Left-overs?
+  procs = $lackey.process
+  if procs.empty?
+    $lackey.close # Causes datalackey to exit. Output closing then exits this.
+    next
+  end
+  if terminate_time.nil? # On first quitting, set terminate time and end feeds.
+    terminate_time = Time.new + arguments.terminate_delay
+    id_list_message('end-feed', procs.keys)
+    next # If terminate delay is 0 this gives a little time for normal exit.
+  end
+  next if (Time.new <=> terminate_time) == -1
+  # Time is up and there are running processes.
+  id_list_message('terminate', procs.keys)
+end
+
+$lackey_proc.finish
+$lackey.close
+$lackey_stderr.close
+$lackey.finish
+if $lackey_proc.exit_code != 0 && !$lackey_proc.exit_code.nil?
+  puts("datalackey exit: #{$lackey_proc.exit_code}")
+end
+exit $exit_code