openc3 7.0.0 → 7.1.0

data/lib/openc3/script/api_shared.rb

@@ -288,6 +288,7 @@ module OpenC3
       start_time = Time.now.sys
       success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
+      value = 'nil' if value.nil? # Show user nil value as 'nil'
       time_diff = Time.now.sys - start_time
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
       if comparison_to_eval
@@ -531,7 +532,7 @@ module OpenC3
       if comparison_to_eval
         _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
       else
-        puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
+        puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value.nil? ? 'nil' : value.inspect}"
       end
     end
 
@@ -632,6 +633,7 @@ module OpenC3
       start_time = Time.now.sys
       success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
+      value = 'nil' if value.nil? # Show user nil value as 'nil'
       time_diff = Time.now.sys - start_time
       wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       value_str = "with value == #{value} after waiting #{time_diff} seconds"
@@ -863,8 +865,20 @@ module OpenC3
       # Show user the check against a quoted string
       # Note: We have to preserve the original 'value' variable because we're going to eval against it
       value_str = value.is_a?(String) ? "'#{value}'" : value
+      value_str = 'nil' if value.nil? # Show user nil value as 'nil'
       with_value = "with value == #{value_str}"
-      if eval(string)
+
+      eval_is_valid = _check_eval_validity(value, comparison_to_eval)
+      unless eval_is_valid
+        message = "Invalid comparison for types"
+        if $disconnect
+          puts "ERROR: #{message}"
+        else
+          raise CheckError, message
+        end
+      end
+
+      if eval_is_valid && eval(string)
         puts "#{check_str} success #{with_value}"
       else
         message = "#{check_str} failed #{with_value}"
@@ -883,5 +897,28 @@ module OpenC3
         raise e
       end
     end
+
+    def _check_eval_validity(value, comparison)
+      return true if comparison.nil? || comparison.empty?
+
+      begin
+        operator, operand = extract_operator_and_operand_from_comparison(comparison)
+      rescue RuntimeError => e
+        if e.message.include?("Unable to parse operand")
+          # If we can't parse the operand, let the eval happen anyway
+          # It will raise an appropriate error (like NameError for undefined constants)
+          return true
+        end
+        raise # Re-raise invalid operator errors
+      rescue JSON::ParserError
+        return true
+      end
+
+      if [">=", "<=", ">", "<"].include?(operator)
+        return false if value.nil? || operand.nil? || value.is_a?(Array) || operand.is_a?(Array)
+      end
+
+      return true
+    end
   end
 end

data/lib/openc3/script/calendar.rb

@@ -61,20 +61,28 @@ module OpenC3
     # @param data [Hash, optional] Additional data to associate with the activity. Defaults to {}. Any activity can provide "username", "notes", and "customTitle". "command", "script", and "reserve" keys are reserves for the corresponding activity kind, with "environment" also available for script activities.
     # @param scope [String, optional] The scope of the activity. Defaults to OPENC3_SCOPE, must correspond to the timeline.
     def create_timeline_activity(name, kind:, start:, stop:, data: {}, scope: $openc3_scope)
-      kind = kind.to_s.downcase()
-      kinds = %w(command script reserve)
-      unless kinds.include?(kind)
-        raise "Unknown kind: #{kind}. Must be one of #{kinds.join(', ')}."
-      end
-      post_data = {}
-      post_data['start'] = start.to_datetime.iso8601
-      post_data['stop'] = stop.to_datetime.iso8601
-      post_data['kind'] = kind
-      post_data['data'] = data
+      post_data = _build_activity_data(kind, start, stop, data)
       response = $api_server.request('post', "/openc3-api/timeline/#{name}/activities", data: post_data, json: true, scope: scope)
       return _cal_handle_response(response, 'Failed to create timeline activity')
     end
 
+    # Updates an existing activity on the specified timeline.
+    #
+    # @param name [String] The name of the timeline.
+    # @param id [Integer] The start time / score of the activity (Unix seconds).
+    # @param kind [String] The kind of activity. Must be one of "COMMAND", "SCRIPT", or "RESERVE".
+    # @param start [DateTime] The new start time of the activity.
+    # @param stop [DateTime] The new stop time of the activity.
+    # @param data [Hash, optional] Additional data to associate with the activity. Defaults to {}. Any activity can provide "username", "notes", and "customTitle". "command", "script", and "reserve" keys are reserved for the corresponding activity kind, with "environment" also available for script activities.
+    # @param uuid [String] The UUID of the activity.
+    # @param scope [String, optional] The scope of the activity. Defaults to OPENC3_SCOPE.
+    def update_timeline_activity(name, id:, kind:, start:, stop:, uuid:, data: {}, scope: $openc3_scope)
+      post_data = _build_activity_data(kind, start, stop, data)
+      url = "/openc3-api/timeline/#{name}/activity/#{id}/#{uuid}"
+      response = $api_server.request('put', url, data: post_data, json: true, scope: scope)
+      return _cal_handle_response(response, 'Failed to update timeline activity')
+    end
+
     def get_timeline_activity(name, start, uuid, scope: $openc3_scope)
       response = $api_server.request('get', "/openc3-api/timeline/#{name}/activity/#{start}/#{uuid}", scope: scope)
       return _cal_handle_response(response, 'Failed to get timeline activity')
@@ -97,6 +105,20 @@ module OpenC3
       return _cal_handle_response(response, 'Failed to delete timeline activity')
     end
 
+    def _build_activity_data(kind, start, stop, data)
+      kind = kind.to_s.downcase()
+      kinds = %w(command script reserve)
+      unless kinds.include?(kind)
+        raise "Unknown kind: #{kind}. Must be one of #{kinds.join(', ')}."
+      end
+      {
+        'start' => start.to_datetime.iso8601,
+        'stop' => stop.to_datetime.iso8601,
+        'kind' => kind,
+        'data' => data,
+      }
+    end
+
     # Helper method to handle the response
     def _cal_handle_response(response, error_message)
       return nil if response.nil?

data/lib/openc3/script/extract.rb

@@ -15,6 +15,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'json'
 require 'openc3/utilities/store'
 
 module OpenC3
@@ -154,22 +155,54 @@ module OpenC3
     end
 
     def extract_fields_from_check_text(text)
-      split_string = text.split
-      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 3
+      target_name, packet_name, item_name, comparison = text.split(nil, 4) # Ruby: second split arg is max number of resultant elements
+      raise "ERROR: Check improperly specified: #{text}" if item_name.nil?
 
-      target_name = split_string[0]
-      packet_name = split_string[1]
-      item_name = split_string[2]
-      comparison_to_eval = nil
-      return [target_name, packet_name, item_name, comparison_to_eval] if split_string.length == 3
-      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 4
+      # comparison is either nil, the comparison string, or an empty string.
+      # We need it to not be an empty string.
+      comparison = nil if comparison&.length == 0
+
+      operator, _ = comparison&.split(nil, 2)
+      raise "ERROR: Use '==' instead of '=' in #{text}" if operator == "="
+
+      return [target_name, packet_name, item_name, comparison]
+    end
+
+    # Splits `check()` comparison expressions, e.g. "== 'foo bar'" becomes ["==", "foo bar"]
+    def extract_operator_and_operand_from_comparison(comparison)
+      valid_operators = ["==", "!=", ">=", "<=", ">", "<", "in"]
 
-      split_string = text.split(/ /) # Split on regex spaces to preserve spaces in comparison
-      index = split_string.rindex(item_name)
-      comparison_to_eval = split_string[(index + 1)..(split_string.length - 1)].join(" ")
-      raise "ERROR: Use '==' instead of '=': #{text}" if split_string[3] == '='
+      operator, operand = comparison.split(nil, 2) # Ruby: second split arg is max number of resultant elements
 
-      return [target_name, packet_name, item_name, comparison_to_eval]
+      if operand.nil?
+        # Don't allow operator without operand
+        raise "ERROR: Invalid comparison, must specify an operand: #{comparison}" if !operator.nil?
+        return [nil, nil]
+      end
+
+      raise "ERROR: Invalid operator: '#{operator}'" unless valid_operators.include?(operator)
+
+      # Handle string operand: remove surrounding double/single quotes
+      if operand.match?(/^(['"])(.*)\1$/m) # Starts with single or double quote, and ends with matching quote
+        operand = operand[1..-2]
+        return [operator, operand]
+      end
+
+      # Handle other operand types
+      if operand == "nil"
+        operand = nil
+      elsif operand == "false"
+        operand = false
+      elsif operand == "true"
+        operand = true
+      else
+        begin
+          operand = JSON.parse(operand)
+        rescue JSON::ParserError
+          raise "ERROR: Unable to parse operand: #{operand}"
+        end
+      end
+      return [operator, operand]
     end
   end
 end

data/lib/openc3/script/script.rb

@@ -44,11 +44,11 @@ require 'openc3/utilities/authentication'
 $api_server = nil
 $script_runner_api_server = nil
 $disconnect = false
-$openc3_scope = ENV['OPENC3_SCOPE'] || 'DEFAULT'
+$openc3_scope = ENV.fetch('OPENC3_SCOPE', 'DEFAULT')
 $openc3_in_cluster = false
 
 saved_verbose = $VERBOSE
-$VERBOSE = false
+$VERBOSE = nil
 
 module OpenC3
   module Script

data/lib/openc3/script/script_runner.rb

@@ -37,9 +37,9 @@ module OpenC3
 
     def script_syntax_check(script, scope: $openc3_scope)
       endpoint = "/script-api/scripts/temp.rb/syntax"
-      # Explicitly set the headers to plain/text so the request.body is set correctly
+      # Explicitly set the headers to text/plain so the request.body is set correctly
       headers = {
-        'Content-Type': 'plain/text',
+        'Content-Type': 'text/plain',
       }
       response = $script_runner_api_server.request('post', endpoint, headers: headers, data: script, scope: scope)
       if response.nil? || response.status != 200
@@ -129,9 +129,9 @@ module OpenC3
 
     def script_instrumented(script, scope: $openc3_scope)
       endpoint = "/script-api/scripts/temp.rb/instrumented"
-      # Explicitly set the headers to plain/text so the request.body is set correctly
+      # Explicitly set the headers to text/plain so the request.body is set correctly
       headers = {
-        'Content-Type': 'plain/text',
+        'Content-Type': 'text/plain',
       }
       response = $script_runner_api_server.request('post', endpoint, headers: headers, data: script, scope: scope)
       if response.nil? || response.status != 200

data/lib/openc3/script/telemetry.rb

@@ -40,9 +40,9 @@ module OpenC3
     # inject_tlm, set_tlm, override_tlm, and normalize_tlm are implemented here simply to add a puts
     # these methods modify the telemetry so the user should be notified in the Script Runner log messages
 
-    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      puts "inject_tlm(\"#{target_name}\", \"#{packet_name}\", #{item_hash}, type: #{type})"
-      $api_server.method_missing(:inject_tlm, target_name, packet_name, item_hash, type: type, scope: scope, token: token)
+    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, scope: $openc3_scope, token: $openc3_token)
+      puts "inject_tlm(\"#{target_name}\", \"#{packet_name}\", #{item_hash}, type: #{type}, stored: #{stored})"
+      $api_server.method_missing(:inject_tlm, target_name, packet_name, item_hash, type: type, stored: stored, scope: scope, token: token)
     end
 
     def set_tlm(*args, type: :ALL, scope: $openc3_scope, token: $openc3_token)

data/lib/openc3/script/web_socket_api.rb

@@ -50,34 +50,41 @@ module OpenC3
       start_time = Time.now
       while true
         message = read_message()
-        if message
+        # Empty string is a normal end-of-stream signal when ActionCable / anycable-go
+        # closes the WS. Treat it the same as nil so consumer `while (resp = api.read)`
+        # loops exit cleanly instead of hitting JSON::ParserError on JSON.parse("").
+        return nil if message.nil? || message.empty?
+
+        begin
           json_hash = JSON.parse(message, allow_nan: true, create_additions: true)
-          if ignore_protocol_messages
-            type = json_hash['type']
-            if type # ping, welcome, confirm_subscription, reject_subscription, disconnect
-              if type == 'disconnect'
-                if json_hash['reason'] == 'unauthorized'
-                  raise "Unauthorized"
-                end
-              end
-              if type == 'reject_subscription'
-                raise "Subscription Rejected"
-              end
-              if timeout
-                end_time = Time.now
-                if (end_time - start_time) > timeout
-                  raise Timeout::Error, "No Data Timeout"
-                end
+        rescue JSON::ParserError
+          # Defense-in-depth: treat malformed frames as end-of-stream rather than crashing.
+          return nil
+        end
+        if ignore_protocol_messages
+          type = json_hash['type']
+          if type # ping, welcome, confirm_subscription, reject_subscription, disconnect
+            if type == 'disconnect'
+              if json_hash['reason'] == 'unauthorized'
+                raise "Unauthorized"
               end
-              if defined? RunningScript and RunningScript.instance
-                raise StopScript if RunningScript.instance.stop?
+            end
+            if type == 'reject_subscription'
+              raise "Subscription Rejected"
+            end
+            if timeout
+              end_time = Time.now
+              if (end_time - start_time) > timeout
+                raise Timeout::Error, "No Data Timeout"
               end
-              next
             end
+            if defined? RunningScript and RunningScript.instance
+              raise StopScript if RunningScript.instance.stop?
+            end
+            next
           end
-          return json_hash['message']
         end
-        return message
+        return json_hash['message']
       end
     end
 

data/lib/openc3/system/system.rb

@@ -77,7 +77,8 @@ module OpenC3
       end
     end
 
-    def self.setup_targets(target_names, base_dir, scope:)
+    # target_version can also be the actual hash used in the target_archives folder
+    def self.setup_targets(target_names, base_dir, target_version: 'current', scope:)
       # Nothing to do if there are no targets
       return if target_names.nil? or target_names.length == 0
       if @@instance.nil?
@@ -85,10 +86,15 @@ module OpenC3
         FileUtils.mkdir_p(targets_path)
         bucket = Bucket.getClient()
         target_names.each do |target_name|
+          # Remove any prior extraction so re-running setup_targets (e.g. after
+          # reset_instance! during reingest) starts from a clean slate. Without
+          # this, Zip::File#extract fails on files left behind by a previous run.
+          FileUtils.rm_rf("#{targets_path}/#{target_name}")
+
           # Retrieve bucket/targets/target_name/<TARGET>_current.zip
-          zip_path = "#{targets_path}/#{target_name}_current.zip"
+          zip_path = "#{targets_path}/#{target_name}_#{target_version}.zip"
           FileUtils.mkdir_p(File.dirname(zip_path))
-          bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_current.zip"
+          bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_#{target_version}.zip"
           Logger.info("Retrieving #{bucket_key} from targets bucket")
           bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: zip_path)
           Zip::File.open(zip_path) do |zip_file|
@@ -116,6 +122,17 @@ module OpenC3
       end
     end
 
+    # Clears the System singleton so the next call to setup_targets or
+    # instance rebuilds it. Intended for admin flows (e.g. reingest) that
+    # need to load a specific target_version distinct from whatever is
+    # currently loaded. Callers must hold an external lock if they need to
+    # protect other threads from observing a nil @@instance briefly.
+    def self.reset_instance!
+      @@instance_mutex.synchronize do
+        @@instance = nil
+      end
+    end
+
     # Get the singleton instance of System
     #
     # @param target_names [Array of target_names]

data/lib/openc3/topics/command_decom_topic.rb

@@ -42,11 +42,13 @@ module OpenC3
       end
       msg_hash['json_data'] = JSON.generate(json_hash.as_json, allow_nan: true)
       msg_hash['extra'] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
-      EphemeralStoreQueued.write_topic(topic, msg_hash)
+      db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
     end
 
     def self.get_cmd_item(target_name, packet_name, param_name, type: :FORMATTED, scope: $openc3_scope)
-      msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
+      msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}", db_shard: db_shard)
       if msg_id
         if param_name == 'RECEIVED_COUNT'
           msg_hash['received_count'].to_i

data/lib/openc3/topics/command_topic.rb

@@ -33,7 +33,8 @@ module OpenC3
                    received_count: packet.received_count,
                    stored: packet.stored.to_s,
                    buffer: packet.buffer(false) }
-      EphemeralStoreQueued.write_topic(topic, msg_hash)
+      db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
     end
 
     # @param command [Hash] Command hash structure read to be written to a topic
@@ -45,20 +46,22 @@ module OpenC3
       command['cmd_params'] = JSON.generate(command['cmd_params'].as_json, allow_nan: true)
       OpenC3.inject_context(command)
 
+      db_shard = Store.db_shard_for_target(command['target_name'], scope: scope)
+
       # Fire-and-forget mode: skip ACK waiting when timeout <= 0
       if timeout <= 0
-        Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100, db_shard: db_shard)
         command["cmd_params"] = cmd_params # Restore the original cmd_params Hash
         return command
       end
 
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{command['target_name']}"
-      Topic.update_topic_offsets([ack_topic])
-      cmd_id = Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100, db_shard: db_shard)
       command["cmd_params"] = cmd_params # Restore the original cmd_params Hash
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == cmd_id
             if msg_hash["result"] == "SUCCESS"
               return command

data/lib/openc3/topics/decom_interface_topic.rb

@@ -26,18 +26,19 @@ module OpenC3
       # DecomMicroservice is listening to the DECOMINTERFACE topic and is responsible
       # for actually building the command. This was deliberate to allow this to work
       # with or without an interface.
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
       decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'build_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+          { 'build_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == decom_id
             if msg_hash["result"] == "SUCCESS"
               return msg_hash
             else
-              raise msg_hash["message"]
+              raise msg_hash["result"]
             end
           end
         end
@@ -45,14 +46,32 @@ module OpenC3
       raise "Timeout of #{timeout}s waiting for cmd ack. Does target '#{target_name}' exist?"
     end
 
-    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope:)
+    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, timeout: 5, scope:)
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['packet_name'] = packet_name.to_s.upcase
       data['item_hash'] = item_hash
       data['type'] = type
-      Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
+      data['stored'] = stored
+      ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
+      decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
+          { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
+      time = Time.now
+      while (Time.now - time) < timeout
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
+          if msg_hash["id"] == decom_id
+            if msg_hash["result"] == "SUCCESS"
+              return
+            else
+              raise msg_hash["result"]
+            end
+          end
+        end
+      end
+      raise "Timeout of #{timeout}s waiting for cmd ack. Does target '#{target_name}' exist?"
     end
 
     def self.get_tlm_buffer(target_name, packet_name, timeout: 5, scope:)
@@ -61,13 +80,14 @@ module OpenC3
       data['packet_name'] = packet_name.to_s.upcase
       # DecomMicroservice is listening to the DECOMINTERFACE topic and has
       # the most recent decommed packets including subpackets
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
       decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'get_tlm_buffer' => JSON.generate(data, allow_nan: true) }, '*', 100)
+          { 'get_tlm_buffer' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == decom_id
             if msg_hash["result"] == "SUCCESS"
               msg_hash["stored"] = ConfigParser.handle_true_false(msg_hash["stored"])
@@ -77,7 +97,7 @@ module OpenC3
               end
               return msg_hash
             else
-              raise msg_hash["message"]
+              raise msg_hash["result"]
             end
           end
         end