cosmos 5.0.2 → 5.0.5

data/lib/cosmos/operators/microservice_operator.rb

@@ -39,7 +39,7 @@ module Cosmos
     end
 
     def convert_microservice_to_process_definition(microservice_name, microservice_config)
-      process_definition = ["ruby", "plugin_microservice.rb", microservice_name]
+      process_definition = ["ruby", "plugin_microservice.rb"]
       work_dir = "/cosmos/lib/cosmos/microservices"
       env = microservice_config["env"].dup
       if microservice_config["needs_dependencies"]
@@ -47,6 +47,7 @@ module Cosmos
       else
         env['GEM_HOME'] = nil
       end
+      env['COSMOS_MICROSERVICE_NAME'] = microservice_name
       container = microservice_config["container"]
       scope = microservice_name.split("__")[0]
       return process_definition, work_dir, env, scope, container

data/lib/cosmos/packets/packet.rb

@@ -98,7 +98,7 @@ module Cosmos
       # @param buffer [String] String buffer to hold the packet data
       # @param item_class [Class] Class used to instantiate items (Must be a
       #   subclass of PacketItem)
-      def initialize(target_name, packet_name, default_endianness = :BIG_ENDIAN, description = nil, buffer = '', item_class = PacketItem)
+      def initialize(target_name, packet_name, default_endianness = :BIG_ENDIAN, description = nil, buffer = nil, item_class = PacketItem)
         super(default_endianness, buffer, item_class)
         # Explictly call the defined setter methods
         self.target_name = target_name
@@ -445,6 +445,11 @@ module Cosmos
       @meta ||= {}
     end
 
+    # Sets packet specific metadata
+    def meta=(meta)
+      @meta = meta
+    end
+
     # Indicates if the packet has been identified
     # @return [TrueClass or FalseClass]
     def identified?
@@ -1009,6 +1014,24 @@ module Cosmos
       config
     end
 
+    def self.from_json(hash)
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil # Convert to symbol
+      packet = Packet.new(hash['target_name'], hash['packet_name'], endianness, hash['description'])
+      packet.short_buffer_allowed = hash['short_buffer_allowed']
+      packet.hazardous = hash['hazardous']
+      packet.hazardous_description = hash['hazardous_description']
+      packet.messages_disabled = hash['messages_disabled']
+      packet.disabled = hash['disabled']
+      packet.hidden = hash['hidden']
+      # packet.stale is read only
+      packet.meta = hash['meta']
+      # Can't convert processors
+      hash['items'].each do |item|
+        packet.define(PacketItem.from_json(item))
+      end
+      packet
+    end
+
     protected
 
     # Performs packet specific processing on the packet.

data/lib/cosmos/packets/packet_config.rb

@@ -463,8 +463,8 @@ module Cosmos
       when 'POLY_READ_CONVERSION', 'POLY_WRITE_CONVERSION'
         usage = "#{keyword} <C0> <C1> <C2> ..."
         parser.verify_num_parameters(1, nil, usage)
-        @current_item.read_conversion = PolynomialConversion.new(params) if keyword.include? "READ"
-        @current_item.write_conversion = PolynomialConversion.new(params) if keyword.include? "WRITE"
+        @current_item.read_conversion = PolynomialConversion.new(*params) if keyword.include? "READ"
+        @current_item.write_conversion = PolynomialConversion.new(*params) if keyword.include? "WRITE"
 
       # Apply a segmented polynomial conversion to the current item
       # after it is read from the telemetry packet

data/lib/cosmos/packets/packet_item.rb

@@ -486,6 +486,63 @@ module Cosmos
       config
     end
 
+    def self.from_json(hash)
+      # Convert strings to symbols
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil
+      data_type = hash['data_type'] ? hash['data_type'].intern : nil
+      overflow = hash['overflow'] ? hash['overflow'].intern : nil
+      item = PacketItem.new(hash['name'], hash['bit_offset'], hash['bit_size'],
+        data_type, endianness, hash['array_size'], overflow)
+      item.description = hash['description']
+      item.id_value = hash['id_value']
+      item.default = hash['default']
+      item.range = (hash['minimum']..hash['maximum']) if hash['minimum'] && hash['maximum']
+      item.required = hash['required']
+      item.format_string = hash['format_string']
+      item.units = hash['units']
+      item.units_full = hash['units_full']
+      if hash['states']
+        item.states = {}
+        item.hazardous = {}
+        item.state_colors = {}
+        hash['states'].each do |state_name, state|
+          item.states[state_name] = state['value']
+          item.hazardous[state_name] = state['hazardous']
+          item.state_colors[state_name] = state['color'].to_sym if state['color']
+        end
+      end
+      # Recreate COSMOS built-in conversions
+      if hash['read_conversion']
+        begin
+          item.read_conversion = Cosmos::const_get(hash['read_conversion']['class']).new(*hash['read_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} read_conversion of #{hash['read_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+      if hash['write_conversion']
+        begin
+          item.write_conversion = Cosmos::const_get(hash['write_conversion']['class']).new(*hash['write_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} write_conversion of #{hash['write_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+
+      if hash['limits']
+        item.limits = PacketItemLimits.new
+        # Delete these keys so the only ones left are limits sets
+        item.limits.persistence_setting = hash['limits'].delete('persistence_setting')
+        item.limits.enabled = true if hash['limits'].delete('enabled')
+        values = {}
+        hash['limits'].each do |set, items|
+          values[set.to_sym] = [items['red_low'], items['yellow_low'], items['yellow_high'], items['red_high']]
+          values[set.to_sym].concat([items['green_low'], items['green_high']]) if items['green_low'] && items['green_high']
+        end
+        item.limits.values = values
+      end
+      item.meta = hash['meta']
+      item
+    end
+
     protected
 
     def parameter_config

data/lib/cosmos/packets/packet_item_limits.rb

@@ -132,7 +132,7 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def as_json
       hash = {}
       hash['values'] = self.values
       hash['enabled'] = self.enabled
@@ -146,5 +146,17 @@ module Cosmos
       hash['persistence_count'] = self.persistence_count
       hash
     end
+
+    def self.from_json(hash)
+      limits = PacketItemLimits.new
+      limits.values = hash['values'].transform_keys(&:to_sym) if hash['values']
+      limits.enabled = hash['enabled']
+      limits.state = hash['state'] ? hash['state'].to_sym : nil
+      # Can't recreate a LimitsResponse class
+      # limits.response = hash['response']
+      limits.persistence_setting = hash['persistence_setting'] if hash['persistence_setting']
+      limits.persistence_count = hash['persistence_count'] if hash['persistence_count']
+      limits
+    end
   end
-end # module Cosmos
+end

data/lib/cosmos/packets/parsers/packet_item_parser.rb

@@ -56,7 +56,7 @@ module Cosmos
       max_options = @usage.count("<")
       # The last two options (description and endianness) are optional
       @parser.verify_num_parameters(max_options - 2, max_options, @usage)
-      @parser.verify_parameters_underscores(1) # Item name is the 1st parameter
+      @parser.verify_parameter_naming(1) # Item name is the 1st parameter
     end
 
     def create_packet_item(packet, cmd_or_tlm)

data/lib/cosmos/packets/parsers/packet_parser.rb

@@ -72,7 +72,7 @@ module Cosmos
     def verify_parameters
       @usage = "#{@parser.keyword} <TARGET NAME> <PACKET NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DESCRIPTION (Optional)>"
       @parser.verify_num_parameters(3, 4, @usage)
-      @parser.verify_parameters_underscores(2) # Packet name is the 2nd parameter
+      @parser.verify_parameter_naming(2) # Packet name is the 2nd parameter
     end
 
     def create_command(target_name, commands, warnings)

data/lib/cosmos/packets/parsers/xtce_parser.rb

@@ -293,7 +293,7 @@ module Cosmos
         xtce_recurse_element(element) do |block_element|
           if block_element.name == 'Term'
             exponent = Float(block_element['exponent']).to_i
-            @current_type.conversion ||= PolynomialConversion.new([])
+            @current_type.conversion ||= PolynomialConversion.new()
             @current_type.conversion.coeffs[exponent] = Float(block_element['coefficient'])
             @current_type.conversion.coeffs.each_with_index do |value, index|
               @current_type.conversion.coeffs[index] = 0.0 if value.nil?

data/lib/cosmos/packets/structure.rb

@@ -66,7 +66,7 @@ module Cosmos
       # @param buffer [String] Buffer used to store the structure
       # @param item_class [Class] Class used to instantiate new structure items.
       #   Must be StructureItem or one of its subclasses.
-      def initialize(default_endianness = BinaryAccessor::HOST_ENDIANNESS, buffer = '', item_class = StructureItem)
+      def initialize(default_endianness = BinaryAccessor::HOST_ENDIANNESS, buffer = nil, item_class = StructureItem)
         if (default_endianness == :BIG_ENDIAN) || (default_endianness == :LITTLE_ENDIAN)
           @default_endianness = default_endianness
           if buffer
@@ -102,14 +102,11 @@ module Cosmos
       def read_item(item, value_type = :RAW, buffer = @buffer)
         return nil if item.data_type == :DERIVED
 
-        if buffer
-          if item.array_size
-            return BinaryAccessor.read_array(item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness)
-          else
-            return BinaryAccessor.read(item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness)
-          end
+        buffer = allocate_buffer_if_needed() unless buffer
+        if item.array_size
+          return BinaryAccessor.read_array(item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness)
         else
-          raise "No buffer given to read_item"
+          return BinaryAccessor.read(item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness)
         end
       end
 
@@ -117,9 +114,8 @@ module Cosmos
       #
       # @return [Integer] Size of the buffer in bytes
       def length
-        return @buffer.length if @buffer
-
-        return 0
+        allocate_buffer_if_needed()
+        return @buffer.length
       end
 
       # Resize the buffer at least the defined length of the structure
@@ -129,12 +125,23 @@ module Cosmos
           if @buffer.length < @defined_length
             @buffer << (ZERO_STRING * (@defined_length - @buffer.length))
           end
+        else
+          allocate_buffer_if_needed()
         end
 
         return self
       end
     end
 
+    # Allocate a buffer if not available
+    def allocate_buffer_if_needed
+      unless @buffer
+        @buffer = ZERO_STRING * @defined_length
+        @buffer.force_encoding(ASCII_8BIT_STRING)
+      end
+      return @buffer
+    end
+
     # Indicates if any items have been defined for this structure
     # @return [TrueClass or FalseClass]
     def defined?
@@ -340,14 +347,11 @@ module Cosmos
     #   parameter to check whether to perform conversions on the item.
     # @param buffer [String] The binary buffer to write the value to
     def write_item(item, value, value_type = :RAW, buffer = @buffer)
-      if buffer
-        if item.array_size
-          BinaryAccessor.write_array(value, item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness, item.overflow)
-        else
-          BinaryAccessor.write(value, item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness, item.overflow)
-        end
+      buffer = allocate_buffer_if_needed() unless buffer
+      if item.array_size
+        BinaryAccessor.write_array(value, item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness, item.overflow)
       else
-        raise "No buffer given to write_item"
+        BinaryAccessor.write(value, item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness, item.overflow)
       end
     end
 
@@ -432,14 +436,11 @@ module Cosmos
     # @param copy [TrueClass/FalseClass] Whether to copy the buffer
     # @return [String] Data buffer backing the structure
     def buffer(copy = true)
-      if @buffer
-        if copy
-          return @buffer.dup
-        else
-          return @buffer
-        end
+      local_buffer = allocate_buffer_if_needed()
+      if copy
+        return local_buffer.dup
       else
-        return nil
+        return local_buffer
       end
     end
 
@@ -525,15 +526,11 @@ module Cosmos
     module MethodMissing
       # Method missing provides reading/writing item values as if they were methods to the class
       def method_missing(name, value = nil)
-        if @buffer
-          if value
-            # Strip off the equals sign before looking up the item
-            return write(name.to_s[0..-2], value)
-          else
-            return read(name.to_s)
-          end
+        if value
+          # Strip off the equals sign before looking up the item
+          return write(name.to_s[0..-2], value)
         else
-          raise "No buffer available for method_missing"
+          return read(name.to_s)
         end
       end
     end

data/lib/cosmos/packets/structure_item.rb

@@ -292,7 +292,16 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def self.from_json(hash)
+      # Convert strings to symbols
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil
+      data_type = hash['data_type'] ? hash['data_type'].intern : nil
+      overflow = hash['overflow'] ? hash['overflow'].intern : nil
+      StructureItem.new(hash['name'], hash['bit_offset'], hash['bit_size'], data_type,
+        endianness, hash['array_size'], overflow)
+    end
+
+    def as_json
       hash = {}
       hash['name'] = self.name
       hash['bit_offset'] = self.bit_offset

data/lib/cosmos/script/api_shared.rb

@@ -300,10 +300,10 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
-    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args, scope: scope, token: token)
       start_time = Time.now.sys
-      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
+      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       with_value_str = "with value == #{value} after waiting #{time} seconds"
@@ -321,8 +321,8 @@ module Cosmos
     end
 
     # @deprecated use wait_check with type: :RAW
-    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait for the value of a telmetry item to be within a tolerance of a value
@@ -334,7 +334,7 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW or :CONVERTED (default)
-    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       raise "Invalid type '#{type}' for wait_check_tolerance" unless %i(RAW CONVERTED).include?(type)
 
       target_name, packet_name, item_name, expected_value, tolerance, timeout, polling_rate = _wait_tolerance_process_args(args, scope: scope, token: token)
@@ -343,7 +343,7 @@ module Cosmos
       if value.is_a?(Array)
         expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance', scope: scope, token: token)
 
-        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
         time = Time.now.sys - start_time
 
         message = ""
@@ -388,8 +388,8 @@ module Cosmos
     end
 
     # @deprecated Use wait_check_tolerance with type: :RAW
-    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.  On a timeout, the script will pause.
@@ -397,12 +397,12 @@ module Cosmos
                               timeout,
                               polling_rate = DEFAULT_TLM_POLLING_RATE,
                               context = nil,
-                              scope: $cosmos_scope, token: $cosmos_token)
+                              scope: $cosmos_scope, token: $cosmos_token, &block)
       start_time = Time.now.sys
       success = cosmos_script_wait_implementation_expression(exp_to_eval,
                                                              timeout,
                                                              polling_rate,
-                                                             context, scope: scope, token: token)
+                                                             context, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       if success
         Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time} seconds"
@@ -691,15 +691,20 @@ module Cosmos
       return [target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate]
     end
 
-    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: $cosmos_scope, token: $cosmos_token)
+    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $cosmos_scope, token: $cosmos_token, &block)
       end_time = Time.now.sys + timeout
-      exp_to_eval = yield
 
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-        if eval(exp_to_eval)
-          return true, value
+        if not block.nil?
+          if block.call(value)
+            return true, value
+          end
+        else
+          if eval(exp_to_eval)
+            return true, value
+          end
         end
         break if Time.now.sys >= end_time
 
@@ -724,25 +729,25 @@ module Cosmos
     end
 
     # Wait for a converted telemetry item to pass a comparison
-    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "value " + comparison_to_eval
+    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      if comparison_to_eval
+        exp_to_eval = "value " + comparison_to_eval
+      else
+        exp_to_eval = nil
       end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
-      end
+    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
+    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
       statements = []
       array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
       exp_to_eval = statements.join(" && ")
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        exp_to_eval
-      end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.

data/lib/cosmos/script/calendar.rb

@@ -18,6 +18,7 @@
 # copyright holder
 
 require 'cosmos/script/extract'
+require 'time'
 
 module Cosmos
   module Script
@@ -25,38 +26,59 @@ module Cosmos
 
     private
 
-    # Sets the metadata value for a target
+    # Gets the current metadata
     #
-    # @param target [String] Target to set metadata on
     # @return The result of the method call.
-    def get_metadata(target)
-      endpoint = "/cosmos-api/metadata/_get/#{target}"
-      response = $api_server.request('get', endpoint)
+    def get_metadata()
+      response = $api_server.request('get', "/cosmos-api/metadata/latest")
       return nil if response.nil? || response.code != 200
       return JSON.parse(response.body)
     end
 
-    # Sets the metadata value for a target
+    # Sets the metadata
     #
-    # @param target [String] Target to set metadata on
     # @param metadata [Hash<Symbol, Variable>] A hash of metadata
-    # @param color [String] Events color to show on Calendar tool
-    # @param start (optional) [String] Metadata time value if nil will default to current time
+    # @param color [String] Events color to show on Calendar tool, if nil will be blue
+    # @param start [Time] Metadata time value, if nil will be current time
     # @return The result of the method call.
-    def set_metadata(target, metadata, color: nil, start: nil)
+    def set_metadata(metadata, color: nil, start: nil)
+      unless metadata.is_a?(Hash)
+        raise "metadata must be a Hash: #{metadata} is a #{metadata.class}"
+      end
       color = color.nil? ? '#003784' : color
-      data = {:color => color, :metadata => metadata, :target => target}
-      data[:start] = start unless start.nil?
+      data = { color: color, metadata: metadata }
+      data[:start] = start.iso8601 unless start.nil?
       response = $api_server.request('post', '/cosmos-api/metadata', data: data, json: true)
       return nil if response.nil? || response.code != 201
       return JSON.parse(response.body)
     end
 
-    # Requests the metadata from the user for a target
+    # Updates the metadata
     #
-    def input_metadata(*args, **kwargs)
-      rasie StandardError "can only be used in script-runner"
+    # @param metadata [Hash<Symbol, Variable>] A hash of metadata
+    # @param color [String] Events color to show on Calendar tool, if nil will be blue
+    # @param start [Integer] Metadata time value as integer seconds from epoch
+    # @return The result of the method call.
+    def update_metadata(metadata, color: nil, start: nil)
+      unless metadata.is_a?(Hash)
+        raise "metadata must be a Hash: #{metadata} is a #{metadata.class}"
+      end
+      color = color.nil? ? '#003784' : color
+      if start == nil
+        existing = get_metadata()
+        start = existing['start']
+        metadata = existing['metadata'].merge(metadata)
+      end
+      data = { :color => color, :metadata => metadata }
+      data[:start] = Time.at(start).iso8601
+      response = $api_server.request('put', "/cosmos-api/metadata/#{start}", data: data, json: true)
+      return nil if response.nil? || response.code != 201
+      return JSON.parse(response.body)
     end
 
+    # Requests the metadata from the user for a target
+    def input_metadata(*args, **kwargs)
+      raise StandardError "can only be used in Script Runner"
+    end
   end
 end

data/lib/cosmos/script/commands.rb

@@ -112,13 +112,11 @@ module Cosmos
           target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args)
           _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         rescue HazardousError => e
-          ok_to_proceed = prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-          if ok_to_proceed
-            target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
-            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
-          else
-            retry unless prompt_for_script_abort()
-          end
+          # This opens a prompt at which point they can cancel and stop the script
+          # or say Yes and send the command. Thus we don't care about the return value.
+          prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
+          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         end
       end
     end

data/lib/cosmos/script/script.rb

@@ -129,58 +129,38 @@ module Cosmos
       message_box(string, *items, **options)
     end
 
-    def _file_dialog(message, directory, filter, select_files = true)
+    def _file_dialog(title, message, filter:)
       answer = ''
-      files = Dir["#{directory}/#{filter}"]
-      if select_files
-        files.select! { |f| !File.directory? f }
-      else
-        files.select! { |f| File.directory? f }
-      end
+      path = "./*"
+      path += filter if filter
+      files = Dir[path]
+      files.select! { |f| !File.directory? f }
       while answer.empty?
-        print message + "\n" + files.join("\n") + "\n<Type file name>:"
+        print "#{title}\n#{message}\n#{files.join("\n")}\n<Type file name>:"
         answer = gets
         answer.chomp!
       end
       return answer
     end
 
-    def save_file_dialog(directory, message = "Save File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_file_dialog(directory, message = "Open File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_files_dialog(directory, message = "Open File(s)", filter = "*")
-      _file_dialog(message, directory, filter)
+    def open_file_dialog(title, message = "Open File", filter:)
+      _file_dialog(title, message, filter)
     end
 
-    def open_directory_dialog(directory, message = "Open Directory")
-      _file_dialog(message, directory, "*", false)
+    def open_files_dialog(title, message = "Open File(s)", filter:)
+      _file_dialog(title, message, filter)
     end
 
     def prompt_for_hazardous(target_name, cmd_name, hazardous_description)
-      message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
-      message << "\n#{hazardous_description}\n" if hazardous_description
-      message << "Send? (y,n): "
-      print message
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        return true
-      else
-        return false
-      end
-    end
-
-    def prompt_for_script_abort
-      print "Stop running script? (y,n): "
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        exit
-      else
-        return false # Not aborted - Retry
+      loop do
+        message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
+        message << "\n#{hazardous_description}\n" if hazardous_description
+        message << "Send? (y): "
+        print message
+        answer = gets.chomp
+        if answer.downcase == 'y'
+          return true
+        end
       end
     end