openc3-cosmos-cfdp 2.4.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb7d5721bf3a141152421c54cdbbeeb08949e23e0ab618c0d2877352325f785f
-  data.tar.gz: 11b2caf95f49b3d27462f89763f14818bedd2c512b20c4c3e2ea35593539a9e7
+  metadata.gz: 4a885fc317d2f4edaa156c1f3a44adce0a75f3ebc2673909f94d404011876361
+  data.tar.gz: 7824550d0da234cdb343886ad2d1e69e338d69b65b8cc31010e025578abf799b
 SHA512:
-  metadata.gz: 36fa4f2bcd087bbeb8e61b31c25d5a6a56df9929a44a5b8d4a881bd7fee91a8c1bcf6e5b1a602c9fc31467f36cac23b9e441db75904ac133990860a7861da124
-  data.tar.gz: c8d6ba0368c1e813e0a618a6fc6d9ed6f212d5a7097ad9c63b49016020228c5fcc20d4fbf2f199223dc12bd7360f05f85e809930e90878350f28f448be3a1d04
+  metadata.gz: fdbeb2b8e886d63646dba3854ce22b3ac042c16eec0580620570f9ffa04b88e78ad23c71e777183cd5852de71bafd6942bd58fbf5e060758454b6c266c43791e
+  data.tar.gz: b40bb71ccdc4e024a70702349e1b1e669d66eb2ff9ad5325381aa4605027df25d9927c93a8a814bd1fc8eca3164b844425c0bc23630f2366e406e60a482e8f69

data/README.md

@@ -149,7 +149,7 @@ These settings are applied to the CFDP microservice via `OPTION <name> <value>`
 | bucket                              | The bucket to send/receive files from. Must be the actual S3 bucket name when using AWS S3 directly (see [Using AWS S3](#using-aws-s3-or-another-s3-service-directly)) | Valid bucket Name | nil - Serve from mounted volume |
 | prevent_received_file_overwrite     | Appends a timestamp to the file name for received files if the file already exists                | true or false     | true                            |
 | allow_duplicate_transaction_ids     | Allows receiving transactions with an ID that was previously used by a completed transaction by deleting the old transaction. Does not affect metadata received for a transaction that is still running, which is never treated as a conflict. | true or false     | false                           |
-| transaction_cleanup_frequency_hours | How often to purge old (completed) transactions from RAM and Redis                                | Any integer       | 24                              |
+| transaction_cleanup_frequency_hours | How often to check for and purge completed transactions from RAM and Redis. A check also runs at startup. How long a completed transaction is kept is set by the local entity's `transaction_retain_seconds`. | Any integer       | 24                              |
 
 > Note: `plugin_test_mode` is a plugin.txt build `VARIABLE` (not a MIB `OPTION`). When set true it installs two dummy entities/targets that can send/receive transactions to each other for testing. It is consumed when the plugin is built, not by the CFDP microservice.
 
@@ -171,7 +171,7 @@ These settings are applied via `OPTION <name> <value>` after declaring the `sour
 | enable_eof_nak                  | Send a NAK in response to a received EOF. Only the local (receiving) entity's value is used.      | true or false                                                                                                                                                                                                                                                                                                                                                       | false               |
 | transaction_closure_requested   | Default closure requested setting used when this engine sends a file. Read from the local entity. | CLOSURE_REQUESTED or CLOSURE_NOT_REQUESTED                                                                                                                                                                                                                                                                                                                          | CLOSURE_REQUESTED   |
 | fault_handler                   | Fault handler setting. Only the local (source) entity's fault handlers are consulted.             | (ACK_LIMIT_REACHED, KEEP_ALIVE_LIMIT_REACHED, INVALID_TRANSMISSION_MODE, FILESTORE_REJECTION, FILE_CHECKSUM_FAILURE, FILE_SIZE_ERROR, NAK_LIMIT_REACHED, INACTIVITY_DETECTED, INVALID_FILE_STRUCTURE, CHECK_LIMIT_REACHED, or UNSUPPORTED_CHECKSUM_TYPE) followed by (ISSUE_NOTICE_OF_CANCELLATION, ISSUE_NOTICE_OF_SUSPENSION, IGNORE_ERROR, or ABANDON_TRANSACTION) | See Code            |
-| transaction_retain_seconds      | Time to keep completed transactions in seconds. Only the source entity's value is used.           | Floating point value greater than 0                                                                                                                                                                                                                                                                                                                                 | 86400               |
+| transaction_retain_seconds      | Time to keep completed (FINISHED, CANCELED or ABANDONED) transactions in seconds before they are purged. Purging happens at startup and every `transaction_cleanup_frequency_hours`, so a transaction can be kept up to that much longer. Cleanup also waits for running source threads and pending Finished acknowledgments. Transactions that never complete are not purged and must be canceled. Only the source entity's value is used. | Floating point value greater than 0                                                                                                                                                                                                                                                                                                                                 | 86400               |
 
 ### Remote (Destination) Entity Configuration
 

data/microservices/CFDP/app/models/cfdp_mib.rb

@@ -765,12 +765,14 @@ class CfdpMib
     CfdpTransaction.clear_saved_transaction_ids
   end
 
-  def self.cleanup_old_transactions
+  def self.cleanup_old_transactions(skip_ids: [])
     current_time = Time.now.utc
     transaction_retain_seconds = @@entities[@@source_entity_id]['transaction_retain_seconds']
     cleaned_up_count = 0
-    @@transactions.each do |id, transaction|
-      if transaction.complete_time and (current_time - transaction.complete_time) > transaction_retain_seconds
+    # Iterate a copy because Rails request threads may add transactions concurrently
+    @@transactions.to_a.each do |id, transaction|
+      next if skip_ids.include?(id)
+      if transaction.complete_time and (current_time - transaction.complete_time) > transaction_retain_seconds and transaction.cleanup_ready?
         transaction.delete
         cleaned_up_count += 1
       end

data/microservices/CFDP/app/models/cfdp_receive_transaction.rb

@@ -204,6 +204,12 @@ class CfdpReceiveTransaction < CfdpTransaction
     end
   end
 
+  # Completion is reported before the positive acknowledgment procedure ends. Retain the
+  # transaction so its Finished PDU can still be retransmitted, including after a restart.
+  def cleanup_ready?
+    super && @finished_ack_timeout.nil?
+  end
+
   def complete_file_received?
     return false unless @file_size
     return true if @file_size == 0
@@ -318,6 +324,7 @@ class CfdpReceiveTransaction < CfdpTransaction
               @condition_code = "ACK_LIMIT_REACHED"
               handle_fault()
               @finished_ack_timeout = nil
+              save_state()
             else
               @finished_ack_timeout = Time.now + CfdpMib.entity(@source_entity_id)['ack_timer_interval']
             end
@@ -637,6 +644,7 @@ class CfdpReceiveTransaction < CfdpTransaction
       'metadata_pdu_hash' => @metadata_pdu_hash,
       'metadata_pdu_count' => @metadata_pdu_count,
       'create_time' => @create_time&.iso8601(6),
+      'complete_time' => @complete_time&.iso8601(6),
       'proxy_response_info' => @proxy_response_info,
       'proxy_response_needed' => @proxy_response_needed,
       'canceling_entity_id' => @canceling_entity_id,

data/microservices/CFDP/app/models/cfdp_source_transaction.rb

@@ -598,6 +598,7 @@ class CfdpSourceTransaction < CfdpTransaction
       end
     end
     @proxy_response_needed = true if @proxy_response_info
+    save_state()
   end
 
   def handle_pdu(pdu_hash)
@@ -724,6 +725,7 @@ class CfdpSourceTransaction < CfdpTransaction
       'metadata_pdu_hash' => @metadata_pdu_hash,
       'metadata_pdu_count' => @metadata_pdu_count,
       'create_time' => @create_time&.iso8601(6),
+      'complete_time' => @complete_time&.iso8601(6),
       'proxy_response_info' => @proxy_response_info,
       'proxy_response_needed' => @proxy_response_needed,
       'canceling_entity_id' => @canceling_entity_id,
@@ -784,6 +786,9 @@ class CfdpSourceTransaction < CfdpTransaction
     @eof_ack_pdu_hash = state_data['eof_ack_pdu_hash']
     @keep_alive_pdu_hash = state_data['keep_alive_pdu_hash']
     @copy_state = state_data['copy_state']
+    # notice_of_completion did not used to save state, so a finished transfer could be saved
+    # with a copy_state of complete while its state was still ACTIVE
+    @complete_time ||= legacy_complete_time if @copy_state == "complete"
     @file_offset = state_data['file_offset']
     @file_checksum = state_data['file_checksum']
     @file_size = state_data['file_size']

data/microservices/CFDP/app/models/cfdp_transaction.rb

@@ -301,6 +301,7 @@ class CfdpTransaction
       'metadata_pdu_hash' => @metadata_pdu_hash,
       'metadata_pdu_count' => @metadata_pdu_count,
       'create_time' => @create_time&.iso8601(6),
+      'complete_time' => @complete_time&.iso8601(6),
       'proxy_response_info' => @proxy_response_info,
       'proxy_response_needed' => @proxy_response_needed,
       'canceling_entity_id' => @canceling_entity_id,
@@ -341,7 +342,10 @@ class CfdpTransaction
     @metadata_pdu_hash = state_data['metadata_pdu_hash']
     @metadata_pdu_count = state_data['metadata_pdu_count'] || 0
     @create_time = state_data['create_time'] ? Time.parse(state_data['create_time']) : nil
-    @complete_time = nil # Completed transactions are not persisted
+    @complete_time = state_data['complete_time'] ? Time.parse(state_data['complete_time']) : nil
+    # State saved before complete_time was persisted has no complete_time even when the
+    # transaction is done, which kept it from ever being cleaned up
+    @complete_time ||= legacy_complete_time if ['FINISHED', 'CANCELED', 'ABANDONED'].include?(@state)
     @proxy_response_info = state_data['proxy_response_info']
     @proxy_response_needed = state_data['proxy_response_needed']
     @canceling_entity_id = state_data['canceling_entity_id']
@@ -353,6 +357,16 @@ class CfdpTransaction
     return state_data
   end
 
+  def cleanup_ready?
+    !@complete_time.nil?
+  end
+
+  # Best estimate of when a completed transaction loaded without a complete_time finished. The
+  # create_time is persisted and always precedes completion.
+  def legacy_complete_time
+    @create_time || Time.now.utc
+  end
+
   def cfdp_cmd(entity, target_name, packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
     cmd(target_name, packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
     cmd_delay(entity['cmd_delay']) if entity['cmd_delay']

data/microservices/CFDP/app/models/cfdp_user.rb

@@ -44,7 +44,9 @@ class CfdpUser
     # Protected by @source_mutex along with @source_transactions.
     @stopping = false
     @source_mutex = Mutex.new
-    @last_cleanup_time = Time.now.utc
+    # nil so cleanup runs on the first pass through the receive loop. Otherwise a microservice
+    # restarted more often than transaction_cleanup_frequency_hours would never clean up.
+    @last_cleanup_time = nil
 
     at_exit do
       stop()
@@ -53,6 +55,9 @@ class CfdpUser
 
   def start
     @source_mutex.synchronize { @stopping = false }
+    # Capture restored transactions before returning to Rails. New Put requests start their
+    # own threads and must not also be resumed after telemetry initialization finishes.
+    transactions_to_resume = CfdpMib.transactions.to_a
     @thread = Thread.new do
       begin
         source_entity = CfdpMib.source_entity
@@ -73,6 +78,9 @@ class CfdpUser
         else
           OpenC3::Topic.update_topic_offsets(topics)
         end
+        # Initialize offsets before resumed transfers can generate replies, and register their
+        # threads before the first cleanup pass so active transfers are protected from deletion.
+        resume_incomplete_source_transactions(transactions_to_resume)
         while !@cancel_thread
           # TODO: Handle freezing transactions if interface disconnects (or target goes unhealthy), and unfreezing if comes back to functional
 
@@ -86,8 +94,8 @@ class CfdpUser
 
           current_time = Time.now.utc
           frequency_seconds = CfdpMib.transaction_cleanup_frequency_hours * 3600
-          if (current_time - @last_cleanup_time) >= frequency_seconds
-            CfdpMib.cleanup_old_transactions()
+          if @last_cleanup_time.nil? or (current_time - @last_cleanup_time) >= frequency_seconds
+            CfdpMib.cleanup_old_transactions(skip_ids: active_source_transaction_ids())
             @last_cleanup_time = current_time
           end
         end
@@ -96,7 +104,6 @@ class CfdpUser
       end
     end
 
-    resume_incomplete_source_transactions
     return @thread
   end
 
@@ -179,6 +186,8 @@ class CfdpUser
           proxy_responses << params
           transaction.proxy_response_needed = false
           transaction.proxy_response_info = nil
+          # Completed transactions are persisted, so the response would be sent again on restart
+          transaction.save_state
         end
       rescue => err
         # A single bad transaction must not take down the receive thread, which would leave the
@@ -199,6 +208,15 @@ class CfdpUser
     end
   end
 
+  # Ids of source transactions whose thread is still running. A canceled transaction already has
+  # a complete_time while its thread finishes sending EOF and waiting for the Finished PDU, so it
+  # must not be cleaned up until the thread is done with it.
+  def active_source_transaction_ids
+    @source_mutex.synchronize do
+      @source_transactions.filter_map { |transaction, thread| transaction.id if thread.alive? }
+    end
+  end
+
   def receive_packet(topic, msg_id, msg_hash, redis)
     topic_split = topic.gsub(/{|}/, '').split("__") # Remove the redis hashtag curly braces
     target_name = topic_split[2]
@@ -278,8 +296,10 @@ class CfdpUser
     return false
   end
 
-  def resume_incomplete_source_transactions()
-    CfdpMib.transactions.each do |transaction_id, transaction|
+  # transactions is a snapshot of CfdpMib.transactions taken by start before Rails can add new
+  # transactions concurrently. Put requests start their own threads and must not be resumed too.
+  def resume_incomplete_source_transactions(transactions)
+    transactions.each do |transaction_id, transaction|
       if transaction_id.split('__')[0].to_i == CfdpMib.source_entity_id && transaction.copy_state != "complete" # && transaction.copy_state != nil?
         # A transaction that was shut down by a previous stop() in this same process would
         # otherwise exit immediately at its first shutdown check

data/microservices/CFDP/spec/models/cfdp_mib_spec.rb

@@ -875,6 +875,7 @@ RSpec.describe CfdpMib do
       allow(@recent_tx).to receive(:delete)
 
       @old_tx = double('Transaction')
+      allow(@old_tx).to receive(:cleanup_ready?).and_return(true)
       allow(@old_tx).to receive(:complete_time).and_return(Time.now.utc - 120)
       allow(@old_tx).to receive(:delete)
 
@@ -919,9 +920,37 @@ RSpec.describe CfdpMib do
       expect(@old_tx).not_to have_received(:delete)
     end
 
+    it 'skips transactions in skip_ids even when they are old' do
+      # A canceled source transaction has a complete_time while its thread is still running
+      CfdpMib.cleanup_old_transactions(skip_ids: ['tx3'])
+      expect(@old_tx).not_to have_received(:delete)
+    end
+
+    %w(FINISHED CANCELED).each do |state|
+      it "retains a restored #{state} receiver until its Finished ACK arrives" do
+        id = '2__123'
+        state_data = { 'id' => id, 'state' => state,
+                       'create_time' => (Time.now.utc - 120).iso8601(6),
+                       'finished_ack_timeout' => (Time.now.utc + 5).iso8601(6) }
+        OpenC3::Store.set("#{CfdpTransaction.redis_key_prefix}cfdp_transaction_state:#{id}", JSON.generate(state_data))
+        transaction = CfdpReceiveTransaction.allocate
+        transaction.load_state(id)
+        CfdpMib.transactions[id] = transaction
+        allow(transaction).to receive(:delete)
+
+        CfdpMib.cleanup_old_transactions
+        expect(transaction).not_to have_received(:delete)
+
+        transaction.handle_pdu({ 'DIRECTIVE_CODE' => 'ACK' })
+        CfdpMib.cleanup_old_transactions
+        expect(transaction).to have_received(:delete)
+      end
+    end
+
     it 'handles multiple old transactions' do
       # Add another old transaction
       old_tx2 = double('Transaction')
+      allow(old_tx2).to receive(:cleanup_ready?).and_return(true)
       allow(old_tx2).to receive(:complete_time).and_return(Time.now.utc - 150)
       allow(old_tx2).to receive(:delete)
       CfdpMib.transactions['tx4'] = old_tx2

data/microservices/CFDP/spec/models/cfdp_receive_transaction_spec.rb

@@ -549,8 +549,11 @@ RSpec.describe CfdpReceiveTransaction do
 
     it "handles finished_ack limit reached" do
       receive_transaction = CfdpReceiveTransaction.new(@metadata_pdu_hash)
+      receive_transaction.instance_variable_set(:@state, "FINISHED")
+      receive_transaction.instance_variable_set(:@complete_time, Time.now.utc - 120)
       receive_transaction.instance_variable_set(:@finished_ack_timeout, Time.now - 1)
       receive_transaction.instance_variable_set(:@finished_pdu, "FINISHED_PDU")
+      receive_transaction.save_state
       expect(receive_transaction).to receive(:handle_fault)
 
       # Set count to reach limit
@@ -559,6 +562,11 @@ RSpec.describe CfdpReceiveTransaction do
 
       expect(receive_transaction.instance_variable_get(:@condition_code)).to eq("ACK_LIMIT_REACHED")
       expect(receive_transaction.instance_variable_get(:@finished_ack_timeout)).to be_nil
+
+      restored = CfdpReceiveTransaction.allocate
+      restored.load_state(receive_transaction.id)
+      expect(restored.condition_code).to eq("ACK_LIMIT_REACHED")
+      expect(restored.cleanup_ready?).to be true
     end
   end
 

data/microservices/CFDP/spec/models/cfdp_source_transaction_spec.rb

@@ -97,6 +97,31 @@ RSpec.describe CfdpSourceTransaction do
     end
   end
 
+  describe "complete_time persistence" do
+    it "saves complete_time when notice_of_completion runs" do
+      mock_redis
+      transaction = CfdpSourceTransaction.new
+      transaction.notice_of_completion
+
+      loaded = CfdpSourceTransaction.new
+      loaded.load_state(transaction.id)
+      expect(loaded.state).to eq("FINISHED")
+      expect(loaded.complete_time.to_f).to be_within(0.001).of(transaction.complete_time.to_f)
+    end
+
+    it "uses create_time as complete_time for a completed copy saved without one" do
+      # notice_of_completion used to not save state, leaving the transaction saved as ACTIVE
+      mock_redis
+      state_data = {"id" => "1__123", "state" => "ACTIVE", "copy_state" => "complete",
+                    "create_time" => "2023-01-01T10:00:00.000000Z"}
+      OpenC3::Store.set("#{CfdpTransaction.redis_key_prefix}cfdp_transaction_state:1__123", JSON.generate(state_data))
+
+      transaction = CfdpSourceTransaction.new
+      transaction.load_state("1__123")
+      expect(transaction.complete_time).to eq(Time.parse("2023-01-01T10:00:00.000000Z"))
+    end
+  end
+
   describe "save_state optimization during file PDU transmission" do
     before(:each) do
       mock_redis()

data/microservices/CFDP/spec/models/cfdp_transaction_spec.rb

@@ -370,6 +370,15 @@ RSpec.describe CfdpTransaction do
         expect(state_data).not_to have_key("file_status")
         expect(state_data).not_to have_key("complete_time")
       end
+
+      it "saves complete_time when the transaction has completed" do
+        mock_redis
+        transaction.instance_variable_set(:@id, "1__123")
+        transaction.abandon
+
+        state_data = JSON.parse(OpenC3::Store.get("#{@redis_prefix}cfdp_transaction_state:1__123"))
+        expect(Time.parse(state_data["complete_time"]).to_f).to be_within(0.001).of(transaction.complete_time.to_f)
+      end
     end
 
     describe "load_state" do
@@ -438,6 +447,38 @@ RSpec.describe CfdpTransaction do
         expect(transaction.condition_code).to eq("NO_ERROR")
         expect(transaction.metadata_pdu_count).to eq(0)
         expect(transaction.instance_variable_get(:@fault_handler_overrides)).to eq({})
+        expect(transaction.complete_time).to be_nil
+      end
+
+      it "loads complete_time" do
+        mock_redis
+        state_data = {"id" => "1__123", "state" => "FINISHED", "create_time" => "2023-01-01T10:00:00.000000Z",
+                      "complete_time" => "2023-01-01T11:00:00.000000Z"}
+        OpenC3::Store.set("#{@redis_prefix}cfdp_transaction_state:1__123", JSON.generate(state_data))
+
+        transaction.load_state("1__123")
+        expect(transaction.complete_time).to eq(Time.parse("2023-01-01T11:00:00.000000Z"))
+      end
+
+      %w(FINISHED CANCELED ABANDONED).each do |state|
+        it "uses create_time as complete_time for a #{state} transaction saved without one" do
+          # State saved by older versions never included complete_time, so these were never cleaned up
+          mock_redis
+          state_data = {"id" => "1__123", "state" => state, "create_time" => "2023-01-01T10:00:00.000000Z"}
+          OpenC3::Store.set("#{@redis_prefix}cfdp_transaction_state:1__123", JSON.generate(state_data))
+
+          transaction.load_state("1__123")
+          expect(transaction.complete_time).to eq(Time.parse("2023-01-01T10:00:00.000000Z"))
+        end
+      end
+
+      it "leaves complete_time nil for an incomplete transaction" do
+        mock_redis
+        state_data = {"id" => "1__123", "state" => "SUSPENDED", "create_time" => "2023-01-01T10:00:00.000000Z"}
+        OpenC3::Store.set("#{@redis_prefix}cfdp_transaction_state:1__123", JSON.generate(state_data))
+
+        transaction.load_state("1__123")
+        expect(transaction.complete_time).to be_nil
       end
     end
 
@@ -483,7 +524,7 @@ RSpec.describe CfdpTransaction do
         expect(new_transaction.metadata_pdu_hash).to eq("abc123")
         expect(new_transaction.metadata_pdu_count).to eq(3)
         expect(new_transaction.create_time.to_i).to eq(original_time.to_i)
-        expect(new_transaction.complete_time).to be_nil # complete_time is not persisted
+        expect(new_transaction.complete_time).to be_nil # Not complete
         expect(new_transaction.proxy_response_info).to eq("proxy_info")
         expect(new_transaction.proxy_response_needed).to be true
         expect(new_transaction.instance_variable_get(:@canceling_entity_id)).to eq(2)

data/microservices/CFDP/spec/models/cfdp_user_spec.rb

@@ -61,6 +61,33 @@ RSpec.describe CfdpUser, type: :model do
   end
 
   describe "start" do
+    it "does not resume a new Put created during telemetry initialization" do
+      CfdpMib.source_entity['tlm_info'] = [['CFDP', 'PDU', 'DATA']]
+      transaction = double('new source transaction', copy_state: nil)
+      expect(transaction).not_to receive(:clear_shutdown)
+      expect(transaction).not_to receive(:copy_file)
+      allow(OpenC3::Topic).to receive(:update_topic_offsets) do
+        CfdpMib.transactions["#{CfdpMib.source_entity_id}__999"] = transaction
+        @user.instance_variable_set(:@cancel_thread, true)
+      end
+
+      @user.start.join(5)
+    end
+
+    it "initializes telemetry offsets before resuming source transactions" do
+      CfdpMib.source_entity['tlm_info'] = [['CFDP', 'PDU', 'DATA']]
+      events = []
+      allow(OpenC3::Topic).to receive(:update_topic_offsets) { events << :offsets }
+      allow(@user).to receive(:resume_incomplete_source_transactions) do
+        events << :resume
+        @user.instance_variable_set(:@cancel_thread, true)
+      end
+
+      @user.start.join(5)
+
+      expect(events).to eq([:offsets, :resume])
+    end
+
     it "sleeps instead of spinning when tlm_info is not configured" do
       # Store.read_topics returns immediately when given no topics, so the receive loop has to
       # pace itself or it pins a CPU for the life of the process
@@ -81,6 +108,49 @@ RSpec.describe CfdpUser, type: :model do
       expect(sleeps).to eq(2)
       expect(OpenC3::Logger).to have_received(:error).with(/tlm_info is not configured/, anything)
     end
+
+    it "cleans up old transactions on the first pass and then only every transaction_cleanup_frequency_hours" do
+      # A microservice restarted more often than the cleanup frequency must still clean up
+      CfdpMib.source_entity['tlm_info'] = []
+      allow(OpenC3::Logger).to receive(:error)
+      allow(CfdpMib).to receive(:cleanup_old_transactions)
+
+      sleeps = 0
+      allow(@user).to receive(:sleep) do |seconds|
+        next unless seconds == CfdpUser::READ_TOPICS_TIMEOUT_S
+        sleeps += 1
+        @user.instance_variable_set(:@cancel_thread, true) if sleeps >= 3
+      end
+
+      @user.start.join(5)
+
+      expect(CfdpMib).to have_received(:cleanup_old_transactions).once
+    end
+
+    it "does not clean up transactions whose resumed source thread is still running" do
+      # A transaction canceled before a restart has an old complete_time but its source thread is
+      # resumed to finish sending EOF, so the first cleanup pass must not delete it out from under it
+      CfdpMib.source_entity['tlm_info'] = []
+      allow(OpenC3::Logger).to receive(:error)
+      cleanup_skip_ids = nil
+      allow(CfdpMib).to receive(:cleanup_old_transactions) { |skip_ids: []| cleanup_skip_ids = skip_ids }
+
+      release = Queue.new
+      transaction = double("transaction", id: "1__5", request_shutdown: nil, save_state: nil)
+      allow(@user).to receive(:resume_incomplete_source_transactions) do
+        @user.register_source_transaction(transaction, Thread.new { release.pop })
+      end
+
+      allow(@user).to receive(:sleep) do |seconds|
+        next unless seconds == CfdpUser::READ_TOPICS_TIMEOUT_S
+        @user.instance_variable_set(:@cancel_thread, true)
+      end
+
+      @user.start.join(5)
+      release << true
+
+      expect(cleanup_skip_ids).to eq(["1__5"])
+    end
   end
 
   describe "update_transactions" do
@@ -98,6 +168,26 @@ RSpec.describe CfdpUser, type: :model do
       expect(good).to have_received(:update)
       expect(OpenC3::Logger).to have_received(:error).with(/1__1 update failed/, anything)
     end
+
+    it "persists that the proxy put response was sent" do
+      # The completed transaction is saved with proxy_response_needed set, so a restart would send
+      # the response again unless clearing it is saved too
+      transaction = CfdpSourceTransaction.new
+      transaction.proxy_response_info = { "SOURCE_ENTITY_ID" => @destination_entity_id, "SEQUENCE_NUMBER" => 5 }
+      transaction.notice_of_completion
+      allow(transaction).to receive(:update)
+      pdu = double("pdu", build_proxy_put_response_message: "response", build_originating_transaction_id_message: "originating")
+      allow(CfdpPdu).to receive(:build_initial_pdu).and_return(pdu)
+      allow(@user).to receive(:start_source_transaction)
+
+      @user.update_transactions
+
+      expect(@user).to have_received(:start_source_transaction).once
+      loaded = CfdpSourceTransaction.new
+      loaded.load_state(transaction.id)
+      expect(loaded.proxy_response_needed).to be false
+      expect(loaded.proxy_response_info).to be_nil
+    end
   end
 
   describe "reap_source_transactions" do
@@ -1014,4 +1104,4 @@ RSpec.describe CfdpUser, type: :model do
       expect(@user.instance_variable_get(:@source_transactions)).to eq([[transaction, source_thread]])
     end
   end
-end
+end

data/plugin.txt

@@ -59,7 +59,7 @@ VARIABLE allow_duplicate_transaction_ids false
   VARIABLE_STATE "TRUE" true
   VARIABLE_STATE "FALSE" false
 VARIABLE transaction_cleanup_frequency_hours 24
-  VARIABLE_DESCRIPTION "How often to purge old (completed) transactions from RAM and Redis"
+  VARIABLE_DESCRIPTION "How often (and at startup) to purge completed transactions older than the source entity transaction_retain_seconds (default 86400) from RAM and Redis"
 
 VARIABLE plugin_test_mode false
   VARIABLE_DESCRIPTION "Install 2 targets: CFDP and CFDP2 along with the CFDP2 microservice configured to talk to CFDP2 target for testing purposes."

data/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openc3-cosmos-cfdp"
-version = "2.2.0"
+version = "0.0.0"
 description = "OpenC3 CFDP - Python Implementation"
 readme = "README.md"
 requires-python = ">=3.12"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openc3-cosmos-cfdp
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.1
 platform: ruby
 authors:
 - Ryan Melton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-11-13 00:00:00.000000000 Z
 dependencies: []
 description: This plugin provides COSMOS Support for CCSDS File Delivery Protocol
   (CFDP). It includes a COSMOS API for sending CFDP commands and an example COSMOS