cosmos 4.5.1 → 5.0.2

data/lib/cosmos/packet_logs/packet_log_writer.rb

@@ -1,353 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'thread'
-require 'socket' # For gethostname
-require 'cosmos/config/config_parser'
-require 'cosmos/packet_logs/packet_log_reader'
-
-module Cosmos
-
-  # Creates a packet log of either commands or telemetry. Can automatically
-  # cycle the log based on an elasped time period or when the log file reaches
-  # a predefined size.
-  class PacketLogWriter
-
-    # @return [String] The filename of the packet log
-    attr_reader :filename
-
-    # @return [true/false] Whether logging is enabled
-    attr_reader :logging_enabled
-
-    # @return [Queue] Queue for asynchronous logging
-    attr_reader :queue
-
-    # The allowable log types
-    LOG_TYPES = [:CMD, :TLM]
-
-    # The cycle time interval. Cycle times are only checked at this level of
-    # granularity.
-    CYCLE_TIME_INTERVAL = 2
-
-    # @param log_type [Symbol] The type of packet log to create. Must be :CMD
-    #   or :TLM.
-    # @param log_name [String|nil] Identifier to put in the log file name. This
-    #   will be prepended with a date / time stamp and appended by the
-    #   log_type. Thus passing 'test' for a :CMD log will result in a filename
-    #   of 'YYYY_MM_DD_HH_MM_SS_testcmd.bin'. Pass nil to ignore this
-    #   parameter.
-    # @param logging_enabled [Boolean] Whether to start with logging enabled
-    # @param cycle_time [Integer] The amount of time in seconds before creating
-    #   a new log file. This can be combined with cycle_size but is better used
-    #   independently.
-    # @param cycle_size [Integer] The size in bytes before creating a new log
-    #   file. This can be combined with cycle_time but is better used
-    #   independently.
-    # @param log_directory [String] The directory to store the log files.
-    #   Passing nil will use the system default 'LOGS' directory.
-    # @param asynchronous [Boolean] Whether to spawn a new thread to write
-    #   packets to the log rather than writing the packets in the current
-    #   thread context.  Note that this is (alot) slower overall but may reduce
-    #   interface receive latency
-    def initialize(
-      log_type,
-      log_name = nil,
-      logging_enabled = true,
-      cycle_time = nil,
-      cycle_size = 2000000000,
-      log_directory = nil,
-      asynchronous = false
-    )
-      raise "log_type must be :CMD or :TLM" unless LOG_TYPES.include? log_type
-      @log_type = log_type
-      if ConfigParser.handle_nil(log_name)
-        @log_name = (log_name.to_s + @log_type.to_s.downcase).freeze
-      else
-        @log_name = @log_type.to_s.downcase.freeze
-      end
-      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
-      @cycle_time = ConfigParser.handle_nil(cycle_time)
-      @cycle_time = Integer(@cycle_time) if @cycle_time
-      @cycle_size = ConfigParser.handle_nil(cycle_size)
-      @cycle_size = Integer(@cycle_size) if @cycle_size
-      if ConfigParser.handle_nil(log_directory)
-        @log_directory = log_directory
-      else
-        @log_directory = System.instance.paths['LOGS']
-      end
-      @asynchronous = ConfigParser.handle_true_false(asynchronous)
-      @queue = Queue.new
-      @mutex = Mutex.new
-      @file = nil
-      @file_size = 0
-      @filename = nil
-      @label = nil
-      @entry_header = String.new
-      @start_time = Time.now.sys
-
-      @cancel_threads = false
-      @logging_thread = nil
-      if @asynchronous
-        @logging_thread = Cosmos.safe_thread("Packet log") do
-          logging_thread_body()
-        end
-      end
-
-      @cycle_thread = nil
-      if @cycle_time
-        @cycle_sleeper = Sleeper.new
-        @cycle_thread = Cosmos.safe_thread("Packet log cycle") do
-          cycle_thread_body()
-        end
-      end
-    end
-
-    # Write a packet to the log file. If the log file was created with
-    # asynchronous = true the packet will be put on a queue and written by the
-    # log writer thread. Otherwise the packet will be written in the caller's
-    # thread context.
-    #
-    # If no log file currently exists in the filesystem, a new file will be
-    # created.
-    #
-    # @param packet [Packet] The packet to write to the log file
-    def write(packet)
-      if @asynchronous
-        @queue << packet.clone
-      else
-        write_packet(packet)
-      end
-    end
-
-    # Starts a new log file by closing the existing log file. New log files are
-    # not created until packets are written by {#write} so this does not
-    # immediately create a log file on the filesystem.
-    #
-    # @param label [String] Label to append to the logfile name. This label
-    #   will be placed after the cmd or tlm in the filename. For example, if
-    #   'test' is given to a command log file, the filename will be
-    #   'YYYY_MM_DD_HH_MM_SS_cmd_test.bin'.
-    def start(label = nil)
-      new_label = label.to_s.strip
-      if new_label.length == 0
-        @label = nil
-      elsif new_label =~ /^[a-zA-Z0-9_-]*$/
-        @label = new_label
-      else
-        # Invalid label - Clear out existing
-        @label = nil
-      end
-
-      @mutex.synchronize { close_file(false); @logging_enabled = true }
-    end
-
-    # Stops all logging and closes the current log file.
-    def stop
-      @mutex.synchronize { @logging_enabled = false; close_file(false) }
-    end
-
-    # Stop all logging, close the current log file, and kill the logging threads.
-    def shutdown
-      stop()
-      if @cycle_thread
-        @cycle_sleeper.cancel
-        Cosmos.kill_thread(self, @cycle_thread)
-        @cycle_thread = nil
-      end
-      Cosmos.kill_thread(self, @logging_thread)
-    end
-
-    def graceful_kill
-      @cancel_threads = true
-      @queue << nil
-    end
-
-    protected
-
-    # Starting a new log file is a critical operation so the entire method is
-    # wrapped with a rescue and handled with handle_critical_exception
-    # Assumes mutex has already been taken
-    def start_new_file(packet = nil)
-      close_file(false)
-      Cosmos.set_working_dir do
-        # Create a filename that doesn't exist
-        attempt = nil
-        while true
-          @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name, @label, attempt], '.bin'))
-          if File.exist?(@filename)
-            attempt ||= 0
-            attempt += 1
-          else
-            break
-          end
-        end
-
-        @file = File.new(@filename, 'wb')
-        @file_size = 0
-      end
-      file_header = build_file_header()
-      if file_header
-        @file.write(file_header)
-        @file_size += file_header.length
-      end
-      @start_time = Time.now.sys
-      Logger.instance.info "Log File Opened : #{@filename}"
-      start_new_file_hook(packet)
-    rescue => err
-      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
-      @logging_enabled = false
-      Cosmos.handle_critical_exception(err)
-    end
-
-    # Adds the meta packet at the beginning of telemetry packet logs
-    # Mutex is held during this hook
-    def start_new_file_hook(packet)
-      # If the first packet is a SYSTEM META packet, make sure the file header matches
-      if packet and packet.target_name == 'SYSTEM'.freeze and packet.packet_name == 'META'.freeze
-        file_header = build_file_header(packet.read('CONFIG'))
-        if file_header
-          @file.seek(0, IO::SEEK_SET)
-          @file.write(file_header)
-          @file_size = file_header.length
-        end
-      else
-        # Else log the first packet as the SYSTEM META packet
-        packet = System.telemetry.packet('SYSTEM', 'META')
-        write_packet(packet, false)
-      end
-    end
-
-    # Closing a log file isn't critical so we just log an error
-    def close_file(take_mutex = true)
-      @mutex.lock if take_mutex
-
-      begin
-        if @file
-          begin
-            @file.close unless @file.closed?
-            Cosmos.set_working_dir do
-              File.chmod(0444, @file.path) # Make file read only
-            end
-            Logger.instance.info "Log File Closed : #{@filename}"
-          rescue Exception => err
-            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
-          end
-
-          @file = nil
-          @file_size = 0
-          @filename = nil
-        end
-      ensure
-        @mutex.unlock if take_mutex
-      end
-    end
-
-    # Writing a log file is a critical operation so the entire method is
-    # wrapped with a rescue and handled with handle_critical_exception
-    def write_packet(packet, take_mutex = true)
-      return if !packet or !@logging_enabled
-      @mutex.lock if take_mutex
-      begin
-        # This check includes logging_enabled again because it might have changed since we acquired the mutex
-        if @logging_enabled and (!@file or (@cycle_size and (@file_size + packet.length) > @cycle_size))
-          start_new_file(packet)
-        end
-        pre_write_entry_hook(packet)
-        if @file
-          @entry_header = build_entry_header(packet) # populate @entry_header
-          if @entry_header
-            @file.write(@entry_header)
-            @file_size += @entry_header.length
-          end
-          buffer = packet.buffer(false)
-          @file.write(buffer)
-          @file_size += buffer.length
-        end
-      ensure
-        @mutex.unlock if take_mutex
-      end
-    rescue => err
-      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
-      Cosmos.handle_critical_exception(err)
-    end
-
-    # Hook to allow access to the packet immediately before writing its entry
-    def pre_write_entry_hook(packet)
-    end
-
-    def logging_thread_body
-      while true
-        begin
-          packet = @queue.pop
-          return if @cancel_threads
-        rescue ThreadError
-          # This can happen when the thread is killed
-          return
-        end
-        write_packet(packet)
-      end
-    end
-
-    def cycle_thread_body
-      while true
-        # The check against start_time needs to be mutex protected to prevent a packet coming in between the check
-        # and closing the file
-        @mutex.synchronize do
-          if @logging_enabled and @cycle_time and (Time.now.sys - @start_time) > @cycle_time
-            close_file(false)
-          end
-        end
-        # Only check whether to cycle at a set interval
-        break if @cycle_sleeper.sleep(CYCLE_TIME_INTERVAL)
-      end
-    end
-
-    def build_file_header(configuration_name = System.configuration_name)
-      hostname = Socket.gethostname.to_s
-      file_header = "COSMOS4_#{@log_type}_#{configuration_name.ljust(32, ' ')[0..31]}_"
-      file_header << hostname.ljust(83)
-      return file_header
-    end
-
-    def build_entry_header(packet)
-      received_time = packet.received_time
-      received_time = Time.now.sys unless received_time
-      # This is an optimization to avoid creating a new entry_header object
-      # each time we create an entry_header which we do a LOT!
-      @entry_header.clear
-      flags = 0
-      flags |= PacketLogReader::COSMOS4_STORED_FLAG_MASK if packet.stored
-      extra = packet.extra
-      if extra
-        flags |= PacketLogReader::COSMOS4_EXTRA_FLAG_MASK
-        extra = extra.to_json
-      end
-      @entry_header << [flags].pack('C'.freeze)
-      if extra
-        @entry_header << [extra.length].pack('N'.freeze)
-        @entry_header << extra
-      end
-      @entry_header << [received_time.tv_sec].pack('N'.freeze)
-      @entry_header << [received_time.tv_usec].pack('N'.freeze)
-      target_name = packet.target_name
-      target_name = 'UNKNOWN'.freeze unless target_name
-      @entry_header << target_name.length
-      @entry_header << target_name
-      packet_name = packet.packet_name
-      packet_name = 'UNKNOWN'.freeze unless packet_name
-      @entry_header << packet_name.length
-      @entry_header << packet_name
-      @entry_header << [packet.length].pack('N'.freeze)
-      return @entry_header
-    end
-
-  end # class PacketLogWriter
-
-end # module Cosmos

data/lib/cosmos/packet_logs/packet_log_writer_pair.rb

@@ -1,30 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-module Cosmos
-
-  # Holds a cmd/tlm pair of packet log writers
-  class PacketLogWriterPair
-
-    # @return [PacketLogWriter] The comamnd log writer
-    attr_reader :cmd_log_writer
-    # @return [PacketLogWriter] The telemetry log writer
-    attr_reader :tlm_log_writer
-
-    # @param cmd_log_writer [PacketLogWriter] The command log writer
-    # @param tlm_log_writer [PacketLogWriter] The telemetry log writer
-    def initialize(cmd_log_writer, tlm_log_writer)
-      @cmd_log_writer = cmd_log_writer
-      @tlm_log_writer = tlm_log_writer
-    end
-
-  end # class PacketLogWriterPair
-
-end # module Cosmos

data/lib/cosmos/packet_logs.rb

@@ -1,6 +0,0 @@
-# encoding: ascii-8bit
-
-require 'cosmos/packet_logs/packet_log_writer'
-require 'cosmos/packet_logs/packet_log_writer_pair'
-require 'cosmos/packet_logs/packet_log_reader'
-require 'cosmos/packet_logs/ccsds_log_reader'

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

@@ -1,121 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'ostruct'
-
-module Cosmos
-  # Parses a macro definition in a command or telemetry configuration file.
-  # Note: Using ERB to define multiple items is now the preferred solution.
-  class MacroParser
-    @macro = nil
-
-    # Adds a new item to the Macro
-    def self.new_item
-      return unless @macro
-      @macro.new_item
-    end
-
-    # Starts a new Macro
-    #
-    # @param parser [ConfigParser] Configuration Parser
-    def self.start(parser)
-      if @macro
-        @macro = nil
-        raise parser.error("First close the previous MACRO_APPEND_START with a MACRO_APPEND_END")
-      else
-        @macro = MacroParser.new(parser)
-      end
-    end
-
-    # Ends the Macro and adds all the items to the packet
-    #
-    # @param parser [ConfigParser] Configuration Parser
-    # @param packet [Packet] Packet to add the macro items to
-    def self.end(parser, packet)
-      raise parser.error("First start a macro with MACRO_APPEND_START") unless @macro
-      @macro.complete(packet)
-    ensure
-      # Ensure this class instance variable gets cleared so we can process the
-      # next call to start
-      @macro = nil
-    end
-
-    # @param parser [ConfigParser] Configuration Parser
-    def initialize(parser)
-      @parser = parser
-      @usage = '#{keyword} <FIRST INDEX> <LAST INDEX> [NAME FORMAT]'
-      parser.verify_num_parameters(2, 3, @usage)
-      @macro = OpenStruct.new(:started => true, :list => [])
-      first_index = parser.parameters[0].to_i
-      last_index  = parser.parameters[1].to_i
-      if first_index < last_index
-        @macro.indices = (first_index..last_index).to_a
-      else
-        @macro.indices = (last_index..first_index).to_a.reverse
-      end
-      @macro.format = parser.parameters[2] ? parser.parameters[2] : '%s%d'
-      @macro.format_order = get_format_order()
-    end
-
-    def new_item
-      if @parser.keyword.include?('APPEND')
-        @macro.list << @parser.parameters[0].upcase
-      end
-    end
-
-    def complete(packet)
-      @parser.verify_num_parameters(0, 0, @parser.keyword)
-      raise @parser.error("Missing MACRO_APPEND_START before this config.line.", @parser.keyword) unless @macro
-      raise @parser.error("No items appended in MACRO_APPEND list", @parser.keyword) if @macro.list.empty?
-
-      create_new_packet_items(packet)
-    end
-
-    private
-
-    def format_item_name(name, index)
-      if @macro.format_order == 'sd'
-        sprintf(@macro.format, name, index)
-      else
-        sprintf(@macro.format, index, name)
-      end
-    end
-
-    def create_new_packet_items(packet)
-      first_index = @macro.indices[0]
-      items = {}
-
-      @macro.indices.each do |index|
-        @macro.list.each do |name|
-          # The first index we just rename the item(s)
-          if index == first_index
-            new_name = format_item_name(name, first_index)
-            items[name] = packet.rename_item(name, new_name)
-          else # Subsequent indexes we clone the first item(s) and append them
-            new_item = items[name].clone
-            new_item.name = format_item_name(name, index)
-            packet.append(new_item)
-          end
-        end
-      end
-    end
-
-    def get_format_order()
-      string_index = @macro.format.index(/%\d*s/)
-      num_index = @macro.format.index(/%\d*d/)
-      raise parser.error("Invalid NAME FORMAT (#{@macro.format}) for MACRO_APPEND_START", @usage) unless string_index && num_index
-      if string_index < num_index
-        @macro.format_order = 'sd'
-      else
-        @macro.format_order = 'ds'
-      end
-    end
-  end
-end

data/lib/cosmos/processors/new_packet_log_processor.rb

@@ -1,39 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/processors/processor'
-
-module Cosmos
-
-  class NewPacketLogProcessor < Processor
-
-    # @param packet_log_writer_name [String] Name of the packet log writer to start new logs on
-    def initialize(packet_log_writer_name = 'ALL')
-      super()
-      @packet_log_writer_name = packet_log_writer_name
-    end
-
-    # Create a new log file
-    #
-    # See Processor#call
-    def call(packet, buffer)
-      if CmdTlmServer.instance and $0 !~ /Replay/
-        CmdTlmServer.instance.start_logging(@packet_log_writer_name)
-      end
-    end
-
-    # Convert to configuration file string
-    def to_config
-      "  PROCESSOR #{@name} #{self.class.name.to_s.class_name_to_filename} #{@packet_log_writer_name}\n"
-    end
-
-  end # class NewPacketLogProcessor
-
-end # module Cosmos