openc3-cosmos-cfdp 1.0.0

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

@@ -0,0 +1,449 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# All Rights Reserved.
+#
+# Licensed for Evaluation and Educational Use
+#
+# This file may only be used commercially under the terms of a commercial license
+# purchased from OpenC3, Inc.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# The development of this software was funded in-whole or in-part by MethaneSAT LLC.
+
+require_relative 'cfdp_transaction'
+
+class CfdpSourceTransaction < CfdpTransaction
+
+  attr_reader :filestore_responses
+
+  def initialize(source_entity: nil)
+    super()
+    @source_entity = source_entity
+    @source_entity = CfdpMib.source_entity unless source_entity
+    raise "No source entity defined" unless @source_entity
+    @transaction_seq_num = CfdpModel.get_next_transaction_seq_num
+    @id = CfdpTransaction.build_transaction_id(@source_entity['id'], @transaction_seq_num)
+    CfdpMib.transactions[@id] = self
+    @finished_pdu_hash = nil
+    @destination_entity = nil
+    @eof_count = 0
+    @filestore_responses = []
+    @metadata_pdu_hash = {} # non-nil to avoid cfdp_user thinking it needs to be set
+  end
+
+  def put(
+    destination_entity_id:,
+    source_file_name: nil,
+    destination_file_name: nil,
+    segmentation_control: "NOT_PRESERVED", # Not supported
+    fault_handler_overrides: [],
+    flow_label: nil, # Not supported
+    transmission_mode: nil,
+    closure_requested: nil,
+    messages_to_user: [],
+    filestore_requests: [])
+
+    raise "destination_entity_id is required" if destination_entity_id.nil?
+    destination_entity_id = Integer(destination_entity_id)
+
+    @source_file_name = source_file_name
+    @destination_file_name = destination_file_name
+    @segmentation_control = segmentation_control
+    @segmentation_control = "NOT_PRESERVED" unless @segmentation_control
+    fault_handler_overrides = [] unless fault_handler_overrides
+    messages_to_user = [] unless messages_to_user
+    filestore_requests = [] unless filestore_requests
+
+    begin
+      transaction_start_notification()
+      copy_file(
+        transaction_seq_num: @transaction_seq_num,
+        transaction_id: @id,
+        destination_entity_id: destination_entity_id,
+        source_file_name: @source_file_name,
+        destination_file_name: @destination_file_name,
+        fault_handler_overrides: fault_handler_overrides,
+        flow_label: flow_label, # Not supported
+        transmission_mode: transmission_mode,
+        closure_requested: closure_requested,
+        messages_to_user: messages_to_user,
+        filestore_requests: filestore_requests
+      )
+    rescue => err
+      abandon()
+      raise err
+    end
+  end
+
+  def transaction_start_notification
+    # Issue Transaction.indication
+    CfdpTopic.write_indication("Transaction", transaction_id: @id)
+  end
+
+  def handle_suspend
+    while @state == "SUSPENDED" or @freeze
+      sleep(1)
+    end
+  end
+
+  def update
+    if @state != "SUSPENDED"
+      if @eof_ack_timeout and Time.now > @eof_ack_timeout and @destination_entity['enable_acks']
+        # Resend eof pdu
+        cmd_params = {}
+        cmd_params[@item_name] = @eof_pdu
+        cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+        @eof_count += 1
+        if @eof_count > @destination_entity['ack_timer_expiration_limit']
+          # Positive ACK Limit Reached Fault
+          @condition_code = "ACK_LIMIT_REACHED"
+          handle_fault()
+          @eof_ack_timeout = nil
+        else
+          @eof_ack_timeout = Time.now + @destination_entity['ack_timer_interval']
+        end
+      end
+    end
+  end
+
+  def copy_file(
+    transaction_seq_num:,
+    transaction_id:,
+    destination_entity_id:,
+    source_file_name:,
+    destination_file_name:,
+    fault_handler_overrides:,
+    flow_label: nil, # Not supported
+    transmission_mode:,
+    closure_requested:,
+    messages_to_user:,
+    filestore_requests:)
+
+    # Lookup outgoing PDU command
+    @source_entity = CfdpMib.source_entity
+    @destination_entity = CfdpMib.entity(destination_entity_id)
+    raise "Unknown destination entity: #{destination_entity_id}" unless @destination_entity
+    @transmission_mode = transmission_mode
+    @transmission_mode = @destination_entity['default_transmission_mode'].upcase unless @transmission_mode
+    @target_name, @packet_name, @item_name = @destination_entity["cmd_info"]
+    raise "cmd_info not configured for destination_entity: #{destination_entity_id}" unless @target_name and @packet_name and @item_name
+
+    if source_file_name and destination_file_name
+      # Prepare file
+      if StringIO === source_file_name
+        source_file = source_file_name
+        source_file_name = destination_file_name
+      else
+        source_file = CfdpMib.get_source_file(source_file_name)
+      end
+      unless source_file
+        abandon()
+        raise "Source file: #{source_file_name} does not exist"
+      end
+
+      file_size = source_file.size
+      read_size = @destination_entity['maximum_file_segment_length']
+    else
+      source_file = nil
+      file_size = 0
+    end
+
+    # Prepare options, ordered by 4.6.1.1.3 c.
+    options = []
+    fault_handler_overrides = [] unless fault_handler_overrides
+    fault_handler_overrides.each do |fho|
+      tlv = {}
+      tlv["TYPE"] = "FAULT_HANDLER_OVERRIDE"
+      tlv["CONDITION_CODE"] = fho[0].to_s.upcase
+      tlv["HANDLER_CODE"] = fho[1].to_s.upcase
+      options << tlv
+      @fault_handler_overrides[tlv["CONDITION_CODE"]] = tlv["HANDLER_CODE"]
+    end
+
+    messages_to_user = [] unless messages_to_user
+    messages_to_user.each do |mtu|
+      tlv = {}
+      tlv["TYPE"] = "MESSAGE_TO_USER"
+      tlv["MESSAGE_TO_USER"] = mtu
+      options << tlv
+    end
+
+    filestore_requests = [] unless filestore_requests
+    filestore_requests.each do |fsr|
+      tlv = {}
+      tlv["TYPE"] = "FILESTORE_REQUEST"
+      tlv["ACTION_CODE"] = fsr[0].to_s.upcase
+      tlv["FIRST_FILE_NAME"] = fsr[1]
+      tlv["SECOND_FILE_NAME"] = fsr[2] if fsr[2]
+      options << tlv
+    end
+
+    if flow_label
+      tlv = {}
+      tlv["TYPE"] = "FLOW_LABEL"
+      tlv["FLOW_LABEL"] = flow_label
+      options << tlv
+    end
+
+    handle_suspend()
+    return if @state == "ABANDONED"
+
+    # Send Metadata PDU
+    @metadata_pdu = CfdpPdu.build_metadata_pdu(
+      source_entity: @source_entity,
+      transaction_seq_num: @transaction_seq_num,
+      destination_entity: @destination_entity,
+      closure_requested: closure_requested,
+      file_size: file_size,
+      source_file_name: source_file_name,
+      destination_file_name: destination_file_name,
+      options: options,
+      segmentation_control: @segmentation_control,
+      transmission_mode: @transmission_mode)
+    cmd_params = {}
+    cmd_params[@item_name] = @metadata_pdu
+    cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+
+    if source_file
+      checksum = get_checksum(@destination_entity['default_checksum_type'])
+      unless checksum
+        # Unsupported algorithm - Use modular instead
+        @condition_code = "UNSUPPORTED_CHECKSUM_TYPE"
+        handle_fault()
+        checksum = CfdpChecksum.new
+      end
+
+      # Send File Data PDUs
+      offset = 0
+      while true
+        break if @state == "CANCELED"
+        handle_suspend()
+        return if @state == "ABANDONED"
+        file_data = source_file.read(read_size)
+        break if file_data.nil? or file_data.length <= 0
+        file_data_pdu = CfdpPdu.build_file_data_pdu(
+          offset: offset,
+          file_data: file_data,
+          file_size: file_size,
+          source_entity: @source_entity,
+          transaction_seq_num: @transaction_seq_num,
+          destination_entity: @destination_entity,
+          segmentation_control: @segmentation_control,
+          transmission_mode: @transmission_mode)
+        cmd_params = {}
+        cmd_params[@item_name] = file_data_pdu
+        cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+        checksum.add(offset, file_data)
+        offset += file_data.length
+        @progress = offset
+      end
+    end
+
+    handle_suspend()
+    return if @state == "ABANDONED"
+
+    # Send EOF PDU
+    if source_file
+      file_checksum = checksum.checksum(source_file, false)
+    else
+      file_checksum = 0
+    end
+    if @canceling_entity_id
+      @condition_code = "CANCEL_REQUEST_RECEIVED"
+      eof_file_size = @progress
+    else
+      eof_file_size = file_size
+    end
+    begin
+      @eof_pdu = CfdpPdu.build_eof_pdu(
+        source_entity: @source_entity,
+        transaction_seq_num: @transaction_seq_num,
+        destination_entity: @destination_entity,
+        file_size: eof_file_size,
+        file_checksum: file_checksum,
+        condition_code: @condition_code,
+        segmentation_control: @segmentation_control,
+        transmission_mode: @transmission_mode,
+        canceling_entity_id: @canceling_entity_id)
+      cmd_params = {}
+      cmd_params[@item_name] = @eof_pdu
+      cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+    rescue => err
+      abandon() if @canceling_entity_id
+      raise err
+    end
+
+    # Issue EOF-Sent.indication
+    CfdpTopic.write_indication("EOF-Sent", transaction_id: transaction_id) if CfdpMib.source_entity['eof_sent_indication']
+
+    @eof_ack_timeout = Time.now + @destination_entity['ack_timer_interval'] if @transmission_mode == "ACKNOWLEDGED"
+
+    @file_status = "UNREPORTED"
+    @delivery_code = "DATA_COMPLETE"
+
+    # Wait for Finished if Closure Requested or Acknowledged Mode
+    if @destination_entity['enable_finished'] and (closure_requested == "CLOSURE_REQUESTED" or @transmission_mode == "ACKNOWLEDGED")
+      start_time = Time.now
+      while (Time.now - start_time) < @source_entity['check_interval']
+        sleep(1)
+        break if @finished_pdu_hash
+      end
+      if @finished_pdu_hash
+        @file_status = @finished_pdu_hash['FILE_STATUS']
+        @delivery_code = @finished_pdu_hash['DELIVERY_CODE']
+        @condition_code = @finished_pdu_hash['CONDITION_CODE'] unless @canceling_entity_id
+      else
+        unless @canceling_entity_id
+          @condition_code = "CHECK_LIMIT_REACHED"
+          handle_fault()
+        end
+      end
+    end
+
+    # Complete use of source file
+    CfdpMib.complete_source_file(source_file) if source_file
+
+    notice_of_completion()
+  end
+
+  def notice_of_completion
+    # Cancel all timeouts
+    @eof_ack_timeout = nil
+
+    if @finished_pdu_hash
+      tlvs = @finished_pdu_hash["TLVS"]
+      if tlvs
+        tlvs.each do |tlv|
+          case tlv['TYPE']
+          when 'FILESTORE_RESPONSE'
+            @filestore_responses << tlv.except('TYPE')
+          end
+        end
+      end
+    end
+    @state = "FINISHED" unless @state == "CANCELED" or @state == "ABANDONED"
+    @transaction_status = "TERMINATED"
+    OpenC3::Logger.info("CFDP Finished Source Transaction #{@id}, #{@condition_code}", scope: ENV['OPENC3_SCOPE'])
+
+    if CfdpMib.source_entity['transaction_finished_indication']
+      if @filestore_responses.length > 0
+        CfdpTopic.write_indication("Transaction-Finished",
+          transaction_id: @id, condition_code: @condition_code,
+          file_status: @file_status, delivery_code: @delivery_code, status_report: @state,
+          filestore_responses: @filestore_responses)
+      else
+        CfdpTopic.write_indication("Transaction-Finished",
+          transaction_id: @id, condition_code: @condition_code,
+          file_status: @file_status, status_report: @state, delivery_code: @delivery_code)
+      end
+    end
+    @proxy_response_needed = true if @proxy_response_info
+  end
+
+  def handle_pdu(pdu_hash)
+    case pdu_hash["DIRECTIVE_CODE"]
+    when "EOF", "METADATA", "PROMPT"
+      # Unexpected - Ignore
+
+    when "FINISHED"
+      @finished_pdu_hash = pdu_hash
+
+      if @finished_pdu_hash["CONDITION_CODE"] == "CANCEL_REQUEST_RECEIVED" and @state != "CANCELED"
+        cancel(@destination_entity.id)
+      end
+
+      if @transmission_mode == "ACKNOWLEDGED" and @destination_entity['enable_acks']
+        # Ack Finished PDU
+        ack_pdu = CfdpPdu.build_ack_pdu(
+          source_entity: @source_entity,
+          transaction_seq_num: @transaction_seq_num,
+          destination_entity: @destination_entity,
+          segmentation_control: @segmentation_control,
+          transmission_mode: @transmission_mode,
+          condition_code: @finished_pdu_hash["CONDITION_CODE"],
+          ack_directive_code: "FINISHED",
+          transaction_status: @transaction_status)
+        cmd_params = {}
+        cmd_params[@item_name] = ack_pdu
+        cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+      end
+
+    when "ACK"
+      # EOF Ack
+      @eof_ack_pdu_hash = pdu_hash
+      @eof_ack_timeout = nil
+
+    when "NAK"
+      handle_nak(pdu_hash)
+
+    when "KEEP_ALIVE"
+      @keep_alive_pdu_hash = pdu_hash
+      if (@progress - @keep_alive_pdu_hash['PROGRESS']) > @destination_entity['keep_alive_discrepancy_limit']
+        @condition_code = "KEEP_ALIVE_LIMIT_REACHED"
+        handle_fault()
+      end
+    else # File Data
+      # Unexpected - Ignore
+    end
+  end
+
+  def handle_nak(pdu_hash)
+    if StringIO === @source_file_name
+      source_file = StringIO.new(@source_file_name.string)
+    else
+      source_file = CfdpMib.get_source_file(@source_file_name)
+    end
+
+    # TODO: Not sure how valid this is in real life
+    # but test code can delete the file from under us
+    return unless source_file
+    file_size = source_file.size
+    max_read_size = @destination_entity['maximum_file_segment_length']
+
+    pdu_hash["SEGMENT_REQUESTS"].each do |request|
+      start_offset = request["START_OFFSET"]
+      end_offset = request["END_OFFSET"]
+
+      if start_offset == 0 and end_offset == 0
+        # Send Metadata PDU
+        cmd_params = {}
+        cmd_params[@item_name] = @metadata_pdu
+        cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+      else
+        # Send File Data PDU(s)
+        offset = start_offset
+        source_file.seek(offset, IO::SEEK_SET)
+        while true
+          bytes_remaining = end_offset - offset
+          break if bytes_remaining <= 0
+          if bytes_remaining >= max_read_size
+            read_size = max_read_size
+          else
+            read_size = bytes_remaining
+          end
+          file_data = source_file.read(read_size)
+          break if file_data.nil? or file_data.length <= 0
+          file_data_pdu = CfdpPdu.build_file_data_pdu(
+            offset: offset,
+            file_data: file_data,
+            file_size: file_size,
+            source_entity: @source_entity,
+            transaction_seq_num: @transaction_seq_num,
+            destination_entity: @destination_entity,
+            segmentation_control: @segmentation_control,
+            transmission_mode: @transmission_mode)
+          cmd_params = {}
+          cmd_params[@item_name] = file_data_pdu
+          cmd(@target_name, @packet_name, cmd_params, scope: ENV['OPENC3_SCOPE'])
+          offset += file_data.length
+        end
+      end
+    end
+
+    CfdpMib.complete_source_file(source_file) if source_file
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# All Rights Reserved.
+#
+# Licensed for Evaluation and Educational Use
+#
+# This file may only be used commercially under the terms of a commercial license
+# purchased from OpenC3, Inc.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# The development of this software was funded in-whole or in-part by MethaneSAT LLC.
+
+require 'openc3/topics/topic'
+require 'openc3/core_ext'
+
+class CfdpTopic < OpenC3::Topic
+  def self.write_indication(indication_type, transaction_id:, **kw_args)
+    msg_hash = {
+      :time => Time.now.to_nsec_from_epoch,
+      :indication_type => indication_type,
+      :transaction_id => transaction_id
+    }
+    kw_args.each do |key, value|
+      msg_hash[key] = value
+    end
+
+    data_hash = {"data" => JSON.generate(msg_hash.as_json(allow_nan: true), allow_nan: true)}
+    OpenC3::Topic.write_topic("#{ENV['OPENC3_MICROSERVICE_NAME']}__CFDP", data_hash, '*', 1000)
+  end
+
+  def self.read_indications(transaction_id: nil, continuation: nil, limit: 1000)
+    continuation = '0-0' unless continuation
+    limit = 1000 unless limit
+    xread = OpenC3::Topic.read_topics(["#{ENV['OPENC3_MICROSERVICE_NAME']}__CFDP"], [continuation], nil, limit) # Always don't block
+    # Return the original continuation and and empty array if we didn't get anything
+    indications = []
+    return {continuation: continuation, indications: indications} if xread.empty?
+    xread.each do |topic, data|
+      data.each do |id, msg_hash|
+        continuation = id
+        msg_hash = JSON.parse(msg_hash["data"], :allow_nan => true, :create_additions => true)
+        if !transaction_id or (transaction_id and msg_hash['transaction_id'] == transaction_id)
+          indications << msg_hash
+        end
+      end
+    end
+    return {continuation: continuation, indications: indications}
+  end
+
+  def self.subscribe_indications
+    id, _ = OpenC3::Topic.get_newest_message("#{ENV['OPENC3_MICROSERVICE_NAME']}__CFDP")
+    return id || '0-0'
+  end
+end

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

@@ -0,0 +1,188 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# All Rights Reserved.
+#
+# Licensed for Evaluation and Educational Use
+#
+# This file may only be used commercially under the terms of a commercial license
+# purchased from OpenC3, Inc.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# The development of this software was funded in-whole or in-part by MethaneSAT LLC.
+
+require 'openc3/api/api'
+require_relative 'cfdp_model'
+require_relative 'cfdp_mib'
+require_relative 'cfdp_topic'
+require_relative 'cfdp_pdu'
+require_relative 'cfdp_checksum'
+require_relative 'cfdp_null_checksum'
+require_relative 'cfdp_crc_checksum'
+require 'tempfile'
+
+class CfdpTransaction
+  include OpenC3::Api
+  attr_reader :id
+  attr_reader :frozen
+  attr_reader :state
+  attr_reader :transaction_status
+  attr_reader :progress
+  attr_reader :transaction_seq_num
+  attr_reader :condition_code
+  attr_reader :delivery_code
+  attr_reader :file_status
+  attr_reader :metadata_pdu_hash
+  attr_reader :metadata_pdu_count
+  attr_accessor :proxy_response_info
+  attr_accessor :proxy_response_needed
+
+  def self.build_transaction_id(source_entity_id, transaction_seq_num)
+    "#{source_entity_id}__#{transaction_seq_num}"
+  end
+
+  def initialize
+    @frozen = false
+    @state = "ACTIVE" # ACTIVE, FINISHED, CANCELED, SUSPENDED, ABANDONED
+    @transaction_status = "ACTIVE" # UNDEFINED, ACTIVE, TERMINATED, UNRECOGNIZED
+    @progress = 0
+    @condition_code = "NO_ERROR"
+    @delivery_code = nil
+    @canceling_entity_id = nil
+    @fault_handler_overrides = {}
+    @metadata_pdu_hash = nil
+    @metadata_pdu_count = 0
+    @proxy_response_info = nil
+    @proxy_response_needed = false
+    @source_file_name = nil
+    @destination_file_name = nil
+  end
+
+  def as_json(*args)
+    return {
+      "id" => @id,
+      "frozen" => @frozen,
+      "state" => @state,
+      "transaction_status" => @transaction_status,
+      "progress" => @progress,
+      "condition_code" => @condition_code,
+      "source_file_name" => @source_file_name,
+      "destination_file_name" => @destination_file_name
+    }
+  end
+
+  def suspend
+    OpenC3::Logger.info("CFDP Suspend Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    if @state == "ACTIVE"
+      @condition_code = "SUSPEND_REQUEST_RECEIVED"
+      @state = "SUSPENDED"
+      CfdpTopic.write_indication("Suspended", transaction_id: @id, condition_code: @condition_code) if CfdpMib.source_entity['suspended_indication']
+    end
+  end
+
+  def resume
+    OpenC3::Logger.info("CFDP Resume Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    if @state == "SUSPENDED"
+      @state = "ACTIVE"
+      @condition_code = "NO_ERROR"
+      @inactivity_timeout = Time.now + CfdpMib.source_entity['keep_alive_interval']
+      CfdpTopic.write_indication("Resumed", transaction_id: @id, progress: @progress) if CfdpMib.source_entity['resume_indication']
+    end
+  end
+
+  def cancel(canceling_entity_id = nil)
+    OpenC3::Logger.info("CFDP Cancel Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    if @state != "FINISHED"
+      @condition_code = "CANCEL_REQUEST_RECEIVED" if @condition_code == "NO_ERROR"
+      if canceling_entity_id
+        @canceling_entity_id = canceling_entity_id
+      else
+        @canceling_entity_id = CfdpMib.source_entity['id']
+      end
+      @state = "CANCELED"
+      @transaction_status = "TERMINATED"
+    end
+  end
+
+  def abandon
+    OpenC3::Logger.info("CFDP Abandon Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    if @state != "FINISHED"
+      @state = "ABANDONED"
+      @transaction_status = "TERMINATED"
+      CfdpTopic.write_indication("Abandoned", transaction_id: @id, condition_code: @condition_code, progress: @progress)
+    end
+  end
+
+  def report
+    CfdpTopic.write_indication("Report", transaction_id: @id, status_report: build_report())
+  end
+
+  def freeze
+    OpenC3::Logger.info("CFDP Freeze Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    @freeze = true
+  end
+
+  def unfreeze
+    OpenC3::Logger.info("CFDP Unfreeze Transaction #{@id}", scope: ENV['OPENC3_SCOPE'])
+    @freeze = false
+  end
+
+  def build_report
+    JSON.generate(as_json(allow_nan: true), allow_nan: true)
+  end
+
+  def handle_fault
+    OpenC3::Logger.error("CFDP Fault Transaction #{@id}, #{@condition_code}", scope: ENV['OPENC3_SCOPE'])
+    if @fault_handler_overrides[@condition_code]
+      case @fault_handler_overrides[@condition_code]
+      when "ISSUE_NOTICE_OF_CANCELLATION"
+        cancel()
+      when "ISSUE_NOTICE_OF_SUSPENSION"
+        suspend()
+      when "IGNORE_ERROR"
+        ignore_fault()
+      when "ABANDON_TRANSACTION"
+        abandon()
+      end
+    else
+      case CfdpMib.source_entity['fault_handler'][@condition_code]
+      when "ISSUE_NOTICE_OF_CANCELLATION"
+        cancel()
+      when "ISSUE_NOTICE_OF_SUSPENSION"
+        suspend()
+      when "IGNORE_ERROR"
+        ignore_fault()
+      when "ABANDON_TRANSACTION"
+        abandon()
+      end
+    end
+  end
+
+  def ignore_fault
+    CfdpTopic.write_indication("Fault", transaction_id: @id, condition_code: @condition_code, progress: @progress)
+  end
+
+  def update
+    # Default do nothing
+  end
+
+  def get_checksum(checksum_type)
+    case checksum_type
+    when 0 # Modular Checksum
+      return CfdpChecksum.new
+    when 1 # Proximity-1 CRC-32 - Poly: 0x00A00805 - Reference CCSDS-211.2-B-3 - Unsure of correct xor/reflect
+      return CfdpCrcChecksum.new(0x00A00805, 0x00000000, false, false)
+    when 2 # CRC-32C - Poly: 0x1EDC6F41 - Reference RFC4960
+      return CfdpCrcChecksum.new(0x1EDC6F41, 0xFFFFFFFF, true, true)
+    when 3 # CRC-32 - Poly: 0x04C11DB7 - Reference Ethernet Frame Check Sequence
+      return CfdpCrcChecksum.new(0x04C11DB7, 0xFFFFFFFF, true, true)
+    when 15
+      return CfdpNullChecksum.new
+    else # Unsupported
+      return nil
+    end
+  end
+end