cosmos 4.1.1-java → 4.2.0-java

data/lib/cosmos/dart/lib/dart_importer.rb

@@ -0,0 +1,154 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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 'dart_common'
+
+# Import COSMOS binary files into the DART database.
+# This code must be run on the database server.
+# The file to be imported should be placed in its final storage location.
+# Note that files are imported in place with algorithms that attempt to prevent
+# duplicate creation of Database entries.
+class DartImporter
+  include DartCommon
+
+  # @param filename [String] Fully qualified filename to import
+  # @param force [Boolean] Whether to reverify all packets in a log file
+  #   are in the database or just abort if the first and last are found.
+  def import(filename, force)
+    Cosmos::Logger.level = Cosmos::Logger::INFO
+
+    # Ensure all defined target and packets are in the database
+    sync_targets_and_packets()
+
+    dart_data_dir = File.expand_path(Cosmos::System.paths['DART_DATA'])
+    directory = File.dirname(File.expand_path(filename))
+    if directory != dart_data_dir
+      Cosmos::Logger.fatal("Imported files must be in \"#{dart_data_dir}\"")
+      Cosmos::Logger.fatal("  File is in: \"#{directory}\"")
+      return 1
+    end
+
+    # Make sure this file isn't already imported
+    packet_log = PacketLog.where("filename = ?", filename).first
+    if packet_log
+      Cosmos::Logger.warn("PacketLog already exists in database: #{filename}")
+    end
+
+    # Determine if this is a command or telemetry packet log
+    begin
+      plr = Cosmos::PacketLogReader.new
+      plr.open(filename)
+      if plr.log_type == :TLM
+        is_tlm = true
+      else
+        is_tlm = false
+      end
+    rescue
+      Cosmos::Logger.fatal("Unable to open #{filename}. Exiting...")
+      return 1
+    end
+
+    # Check if first and last packet in the log are already in the database
+    last_packet = plr.last
+    first_packet = plr.first
+    plr.close
+    unless first_packet and last_packet
+      Cosmos::Logger.fatal("No packets found in file. Exiting...")
+      return 1
+    end
+
+    first_ple = find_packet_log_entry(first_packet, is_tlm)
+    last_ple = find_packet_log_entry(last_packet, is_tlm)
+
+    fast = false
+    if first_ple and last_ple
+      Cosmos::Logger.warn("First and Last Packet in File Already in Database.")
+      if force
+        Cosmos::Logger.warn("Reverifying all packets in database due to force...")
+      else
+        Cosmos::Logger.info("Complete")
+        return 1
+      end
+    elsif !first_ple and !last_ple
+      Cosmos::Logger.info("First and Last Packet in File not in database")
+
+      # Check if time range of packets is not present in database
+      ple = PacketLogEntry.where("time >= ? or time <= ?", first_packet.received_time, last_packet.received_time).first
+      if !ple # Can go fast if not present at all
+        Cosmos::Logger.info("  Fast Import Enabled...")
+        fast = true
+      end
+    else
+      Cosmos::Logger.warn("File partially in database. Will verify each packet before adding")
+    end
+
+    unless packet_log
+      Cosmos::Logger.info("Creating PacketLog entry for file: #{filename}")
+      packet_log = PacketLog.create(:filename => filename, :is_tlm => is_tlm)
+    end
+
+    # Read File and Create PacketLogEntries
+    count = 0
+    meta_id = nil
+    plr.open(filename)
+    data_offset = plr.bytes_read
+    plr.each(filename) do |packet|
+      target_name = packet.target_name
+      target_name = 'UNKNOWN' unless target_name
+      packet_name = packet.packet_name
+      packet_name = 'UNKNOWN' unless packet_name
+
+      target_id, packet_id = lookup_target_and_packet_id(target_name, packet_name, is_tlm)
+
+      # If packets aren't found in the database we don't have to bother looking
+      # for PacketLogEntrys in the database and can simply create new entries
+      if fast
+        ple = nil
+      else # File is partially in the DB so see if the packet already exists
+        ple = find_packet_log_entry(packet, is_tlm)
+      end
+
+      # No PacketLogEntry was found so create one from scratch
+      unless ple
+        ple = PacketLogEntry.new
+        ple.target_id = target_id
+        ple.packet_id = packet_id
+        ple.time = packet.received_time
+        ple.packet_log_id = packet_log.id
+        ple.data_offset = data_offset
+        ple.meta_id = meta_id
+        ple.is_tlm = is_tlm
+        ple.ready = true
+        ple.save!
+        count += 1
+
+        # SYSTEM META packets are special in that their meta_id is their own
+        # PacketLogEntry ID from the database. All other packets have meta_id
+        # values which point back to the last SYSTEM META PacketLogEntry ID.
+        if target_name == 'SYSTEM'.freeze and packet_name == 'META'.freeze
+          # Need to update meta_id for this and all subsequent packets
+          meta_id = ple.id
+          ple.meta_id = meta_id
+          ple.save!
+        end
+      else # A PacketLogEntry was found so this packet is skipped
+        # If the packet is a SYSTEM META packet we keep track of the meta_id
+        # for use in subsequent packets that aren't already in the database.
+        if target_name == 'SYSTEM'.freeze and packet_name == 'META'.freeze
+          # Need to update meta_id for subsequent packets
+          meta_id = ple.id
+        end
+      end
+      data_offset = plr.bytes_read
+    end
+    Cosmos::Logger.info("Added #{count} packet log entries to database")
+    return 0 # Success code
+  end
+end

data/lib/cosmos/dart/lib/dart_logging.rb

@@ -0,0 +1,50 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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'
+require 'stringio'
+
+# Creates a MessageLog in the DART_LOGS System path for DART logging
+class DartLogging
+  def initialize(message_log_name)
+    @output_sleeper = Cosmos::Sleeper.new
+    @string_output = StringIO.new("", "r+")
+    $stdout = @string_output
+    @message_log = Cosmos::MessageLog.new(message_log_name, Cosmos::System.paths['DART_LOGS'])
+
+    @output_thread = Thread.new do
+      while true
+        handle_string_output()
+        break if @output_sleeper.sleep(1)
+      end
+    end
+  end
+
+  def handle_string_output
+    if @string_output.string[-1..-1] == "\n"
+      string = @string_output.string.clone
+      @string_output.string = @string_output.string[string.length..-1]
+      @message_log.write(string, true)
+      STDOUT.print string if STDIN.isatty # Have a console
+    end
+  end
+
+  def graceful_kill
+    # Do Nothing
+  end
+
+  def stop
+    handle_string_output()
+    @output_sleeper.cancel
+    Cosmos.kill_thread(self, @output_thread)
+    handle_string_output()
+    @message_log.stop
+  end
+end

data/lib/cosmos/dart/lib/dart_packet_log_writer.rb

@@ -0,0 +1,139 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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 'dart_common'
+
+# Writes all packets to a log file for use by the DART database.
+# The PacketLog table hold the binary file name.
+# As each packet is written to disk the location of the packet
+# is recorded in the PacketLogEntry table for quick access.
+class DartPacketLogWriter < Cosmos::PacketLogWriter
+  include DartCommon
+
+  DEFAULT_SYNC_COUNT_LIMIT = 100
+
+  # Initialize the database by synchronizing all known targets and
+  # packet names to the Target and Packet tables. Start the thread
+  # which updates the PacketLogEntry table when new packets arrive.
+  def initialize(*args)
+    super(*args)
+    @packet_log_id = nil
+    @meta_id = nil
+    @db_queue = Queue.new
+    @sync_count = 0
+    @sync_count_limit = DEFAULT_SYNC_COUNT_LIMIT
+    @not_ready_ple_ids = []
+
+    sync_targets_and_packets()
+
+    @db_thread = Cosmos.safe_thread("Database packet log entries") do
+      db_thread_body()
+    end
+  end
+
+  # Kill the database update thread
+  def shutdown
+    super()
+    Cosmos.kill_thread(self, @db_thread)
+  end
+
+  # Kick the database update thread to allow it to quit
+  def graceful_kill
+    super()
+    @db_queue << nil
+  end
+
+  protected
+
+  # Override the default new file hook to create a PacketLog entry in the database
+  def start_new_file_hook(packet)
+    # When we create a new file we mark any existing PLEs ready
+    PacketLogEntry.where("id" => @not_ready_ple_ids).update_all(ready: true)
+    @not_ready_ple_ids.clear
+    @sync_count = 0
+
+    packet_log = PacketLog.new
+    packet_log.filename = @filename.clone
+    if @log_type == :TLM
+      packet_log.is_tlm = true
+    else
+      packet_log.is_tlm = false
+    end
+    packet_log.save!
+    @packet_log_id = packet_log.id
+    super(packet)
+  end
+
+  # Override the default pre write hook to pop a message on the queue which
+  # will be processed by the database thread. This also writes out the log
+  # files to disk periodically for use by other DART processes.
+  def pre_write_entry_hook(packet)
+    @sync_count += 1
+    if @sync_count > @sync_count_limit
+      @file.fsync
+      @sync_count = 0
+    end
+    @db_queue << [packet.target_name, packet.packet_name, packet.received_time, @file_size, @packet_log_id, @sync_count]
+  end
+
+  # Build the target / packet table lookup table and then wait on the queue
+  # being populated by the pre_write_entry_hook thread to add rows to the
+  # PacketLogEntry table. Each entry identifies a packet in the log file by
+  # its target, packet, time, and data offset (among other things).
+  def db_thread_body
+    if @log_type == :TLM
+      is_tlm = true
+    else
+      is_tlm = false
+    end
+
+    while true
+      begin
+        target_name, packet_name, time, data_offset, packet_log_id, sync_count = @db_queue.pop
+        # Every time the sync_count resets by the pre_write_entry_hook the file
+        # is written out to disk. Thus we mark all the PacketLogEntrys to ready
+        # since we know the packets have been written to disk.
+        if sync_count == 0 or sync_count.nil?
+          PacketLogEntry.where("id" => @not_ready_ple_ids).update_all(ready: true)
+          @not_ready_ple_ids.clear
+        end
+        return if @cancel_threads or sync_count.nil?
+      rescue ThreadError
+        # This can happen when the thread is killed
+        return
+      end
+
+      target_id, packet_id = lookup_target_and_packet_id(target_name, packet_name, is_tlm)
+
+      ple = PacketLogEntry.new
+      ple.target_id = target_id
+      ple.packet_id = packet_id
+      ple.time = time
+      ple.packet_log_id = packet_log_id
+      ple.data_offset = data_offset
+      ple.meta_id = @meta_id
+      ple.is_tlm = is_tlm
+      ple.ready = false
+      ple.save!
+
+      # SYSTEM META packets are special in that their meta_id is their own
+      # PacketLogEntry ID from the database. All other packets have meta_id
+      # values which point back to the last SYSTEM META PacketLogEntry ID.
+      if target_name == 'SYSTEM'.freeze and packet_name == 'META'.freeze
+        # Need to update meta_id for this and all subsequent packets
+        @meta_id = ple.id
+        ple.meta_id = @meta_id
+        ple.save!
+      end
+      # Remember this new PacketLogEntry so we can mark it ready later
+      @not_ready_ple_ids << ple.id
+    end
+  end
+end

data/lib/cosmos/dart/lib/dart_reducer_manager.rb

@@ -0,0 +1,85 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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 'dart_reducer_worker_thread'
+
+# Reduce the decommutated data into the database. It creates a number of
+# threads to perform the actual data reduction. Then it queries the database
+# for all the decommutation tables and determines which need to be reduced
+# by minute, hour, and day.
+class DartReducerManager
+  include DartCommon
+
+  # Create worker threads to perform the data reduction
+  #
+  # @param num_threads [Integer] The number of worker threads to create
+  def initialize(num_threads = 5)
+    Cosmos::Logger.info("Dart Reducer Starting with #{num_threads} threads...")
+    @master_queue = Queue.new
+    @locked_tables = []
+    @mutex = Mutex.new
+    @threads = []
+    num_threads.times do |index|
+      @threads << DartReducerWorkerThread.new(@master_queue, @locked_tables, @mutex, index + 1)
+    end
+  end
+
+  # Shutdown each of the worker threads
+  def shutdown
+    @threads.each {|thread| thread.shutdown}
+    @threads.each {|thread| thread.join}
+  end
+
+  # Search through all the tables in the database looking for decommutation tables
+  # and reduction tables. Then push all found tables onto one of the worker
+  # thread queues for processing.
+  def run
+    begin
+      while true
+        time_start = Time.now
+        # Find base tables that need to be reduced
+        base_tables = []
+        each_decom_and_reduced_table() do |packet_config_id, table_index, decom_model, minute_model, hour_model, day_model|
+          queue_worker(:MINUTE, packet_config_id, table_index, decom_model, minute_model)
+          queue_worker(:HOUR, packet_config_id, table_index, minute_model, hour_model)
+          queue_worker(:DAY, packet_config_id, table_index, hour_model, day_model)
+        end
+        # Throttle to no faster than once every 60 seconds
+        delta = Time.now - time_start
+        if delta < 60 and delta > 0
+          sleep(60 - delta)
+        end
+      end
+    rescue Interrupt
+      Cosmos::Logger.info("Dart Reducer Shutting Down...")
+      shutdown()
+      exit(0)
+    end
+  end
+
+  protected
+
+  # Add a task to a worker thread queue
+  #
+  # @param type [Symbol] One of :MINUTE, :HOUR, :DAY
+  # @param packet_config_id [Integer] PacketConfig ID from the database
+  # @param table_index [Integer] Table index used in table names
+  # @param base_model [ActiveRecord] Database model of the table to be reduced
+  # @param reduction_model [ActiveRecord] Database model of the reduction table
+  def queue_worker(type, packet_config_id, table_index, base_model, reduction_model)
+    thread_queue = @master_queue.pop
+    unless @locked_tables.include?([type, packet_config_id, table_index])
+      @mutex.synchronize do
+        @locked_tables << ([type, packet_config_id, table_index])
+      end
+      thread_queue << [type, packet_config_id, table_index, base_model, reduction_model]
+    end
+  end
+end

data/lib/cosmos/dart/lib/dart_reducer_worker_thread.rb

@@ -0,0 +1,263 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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 'dart_common'
+
+ItemToDecomTableMapping
+
+# Thread which performs data reduction in the DART database.
+class DartReducerWorkerThread
+  # Create a new thread and start it
+  #
+  # @param master_queue [Queue] Queue which the new thread will be added to
+  # @param locked_tables [Array<Array<Symbol, Integer, Integer>>] Array of
+  #   all the tables which are currently being processed. The first parameter
+  #   is the table type and must be :MINUTE, :HOUR or :DAY. The second and
+  #   third values are the PacketConfig ID and table index.
+  # @param mutex [Mutex] Mutex used to synchronize access to the locked_tables
+  # @param instance_num [Integer] Simple counter to trace the thread instance
+  def initialize(master_queue, locked_tables, mutex, instance_num)
+    @instance_num = instance_num
+    @running = true
+    @master_queue = master_queue
+    @locked_tables = locked_tables
+    @mutex = mutex
+    @thread_queue = Queue.new
+    # Start the thread which will wait on @thread_queue.pop
+    @thread = Thread.new { work() }
+    # Add the local @thread_queue to the @master_queue so jobs can be added
+    @master_queue << @thread_queue
+  end
+
+  # Pop a job off the queue and find items which are able to be reduced.
+  # Calculate the min, max, and average value over the reduction period
+  # (min, hour, or day) and save to the reduction table tXXX_YYY_Z where
+  # XXX is the PacketConfig ID, YYY is the table index, and Z is 'm', 'h', or 'd'
+  # (minute, hour, day).
+  def work
+    while @running # Set to false in shutdown()
+      job_type, packet_config_id, table_index, base_model, reduction_model = @thread_queue.pop
+      break unless job_type # shutdown was called
+
+      # Find all the items which are able to be reduced (reduced = true)
+      mappings = ItemToDecomTableMapping.where("packet_config_id = ? and table_index = ? and reduced = true",
+        packet_config_id, table_index)
+      # The only way to not have any mappings is if the packet contains no items
+      # which can be reduced (no integer or float values). This would be extremely rare.
+      if mappings.length == 0
+        Cosmos::Logger.debug("No Mappings for JobType #{job_type}: #{packet_config_id}: #{table_index}")
+        complete_job(job_type, packet_config_id, table_index)
+        next
+      end
+
+      time_delta, base_model_time_column, time_method = job_attributes(job_type)
+      rows = []
+      # Find all the rows in the decommutation table which are ready to reduce
+      base_model.where("reduced_state = #{DartCommon::READY_TO_REDUCE}").order("meta_id ASC, #{base_model_time_column} ASC").find_each do |row|
+        rows << row
+        first_row_time = rows[0].send(base_model_time_column)
+        last_row_time = rows[-1].send(base_model_time_column)
+        # Ensure we have conditions to process the reduction data
+        next unless (last_row_time - first_row_time) > time_delta || # Enough samples or
+            # The time attribute (min, hour, day) has changed or
+            first_row_time.send(time_method) != last_row_time.send(time_method) ||
+            rows[0].meta_id != rows[-1].meta_id # New meta data
+
+        # Sample from the start to the second to last row because the last row
+        # is where we detected a change. The last row will be part of a new sample set.
+        sample_rows = rows[0..-2]
+        new_row = reduction_model.new
+        new_row.start_time = first_row_time
+        new_row.num_samples = sample_rows.length
+        new_row.meta_id = sample_rows[0].meta_id
+        # Process each of the ItemToDecomTableMapping to get the item to be reduced
+        mappings.each do |mapping|
+          item_name = "i#{mapping.item_index}"
+          min_item_name = "i#{mapping.item_index}min"
+          max_item_name = "i#{mapping.item_index}max"
+          avg_item_name = "i#{mapping.item_index}avg"
+          stddev_item_name = "i#{mapping.item_index}stddev"
+          min_value = nil
+          max_value = nil
+          total_samples = 0 # s0
+          avg_value = 0.0 # s1
+          s2 = 0.0
+          stddev_value = 0.0
+          min_nan_found = false
+          max_nan_found = false
+          avg_nan_found = false
+          stddev_nan_found = false
+          # Process each of the rows in the base model which is the decommutation table
+          # or a lesser reduction table (the minute or hour table).
+          sample_rows.each do |row_to_reduce|
+            # If we processing minute data we're reading from the base decommutation table
+            # thus there is only raw values to read
+            if job_type == :MINUTE
+              value = row_to_reduce.read_attribute(item_name)
+              min_sample = value
+              max_sample = value
+              avg_sample = value
+              if value.nil?
+                Cosmos::Logger.error("#{item_name} is nil in #{row_to_reduce.class}:#{row_to_reduce.id}")
+                next
+              end
+            else # :HOUR or :DAY
+              # We're processing hour or day data so we're reducing previously reduced data
+              # thus there are min, max, and average values to read
+              min_sample = row_to_reduce.read_attribute(min_item_name)
+              max_sample = row_to_reduce.read_attribute(max_item_name)
+              avg_sample = row_to_reduce.read_attribute(avg_item_name)
+              stddev_sample = row_to_reduce.read_attribute(stddev_item_name)
+              if min_sample.nil?
+                Cosmos::Logger.error("#{min_item_name} is nil in #{row_to_reduce.class}:#{row_to_reduce.id}")
+                next
+              end
+              if max_sample.nil?
+                Cosmos::Logger.error("#{max_item_name} is nil in #{row_to_reduce.class}:#{row_to_reduce.id}")
+                next
+              end
+              if avg_sample.nil?
+                Cosmos::Logger.error("#{avg_item_name} is nil in #{row_to_reduce.class}:#{row_to_reduce.id}")
+                next
+              end
+              if stddev_sample.nil?
+                Cosmos::Logger.error("#{stddev_item_name} is nil in #{row_to_reduce.class}:#{row_to_reduce.id}")
+                next
+              end
+            end
+
+            if nan_value?(min_sample)
+              min_nan_found = true
+            else
+              if !min_value or min_sample < min_value
+                min_value = min_sample
+              end
+            end
+
+            if nan_value?(max_sample)
+              max_nan_found = true
+            else
+              if !max_value or max_sample > max_value
+                max_value = max_sample
+              end
+            end
+
+            if nan_value?(avg_sample)
+              avg_nan_found = true
+            else
+              # MINUTE data is reducing the decommutated values
+              if job_type == :MINUTE
+                total_samples += 1 # s0
+                avg_value += avg_sample # s1
+                s2 += (avg_sample * avg_sample)
+              else # :HOUR or :DAY
+                # Aggregated Stddev
+                # See https://math.stackexchange.com/questions/1547141/aggregating-standard-deviation-to-a-summary-point
+                total_samples += row_to_reduce.num_samples # s0
+                avg_value += (avg_sample * row_to_reduce.num_samples) # s1
+                s2 += row_to_reduce.num_samples * (avg_sample * avg_sample + stddev_sample * stddev_sample)
+              end
+            end
+          end
+          if total_samples != 0
+            # Aggregated Stddev
+            # See https://math.stackexchange.com/questions/1547141/aggregating-standard-deviation-to-a-summary-point
+            avg_value = avg_value.to_f / total_samples
+            # Note: For very large numbers with very small deviations this sqrt can fail.  If so then just set the stddev to 0.
+            begin
+              stddev_value = sqrt((s2 / total_samples) - (avg_value * avg_value))
+            rescue Exception
+              stddev_value = 0.0
+            end
+          end
+          min_value = Float::NAN if min_nan_found and !min_value
+          max_value = Float::NAN if max_nan_found and !max_value
+          if avg_nan_found and total_samples == 0
+            avg_value = Float::NAN
+            stddev_value = Float::NAN
+          end
+          new_row.write_attribute(min_item_name, min_value)
+          new_row.write_attribute(max_item_name, max_value)
+          new_row.write_attribute(avg_item_name, avg_value)
+          new_row.write_attribute(stddev_item_name, stddev_value)
+        end
+        base_model.where(id: sample_rows.map(&:id)).update_all(:reduced_state => DartCommon::REDUCED)
+        new_row.save! # Create the reduced data row in the database
+        base_model.where(id: sample_rows.map(&:id)).update_all(:reduced_id => new_row.id)
+        new_row.reduced_state = DartCommon::READY_TO_REDUCE
+        new_row.save!
+
+        rows = rows[-1..-1] # Start a new sample with the last item in the previous sample
+        Cosmos::Logger.debug("Created #{new_row.class}:#{new_row.id} with #{mappings.length} items from #{new_row.num_samples} samples")
+      end
+      complete_job(job_type, packet_config_id, table_index)
+    end # while @running
+    Cosmos::Logger.info("Reducer Thread #{@instance_num} Shutdown")
+  rescue Exception => error
+    Cosmos::Logger.error("Reducer Thread Unexpectedly Died: #{error.formatted}")
+  end
+
+  # Shutdown the worker thread
+  def shutdown
+    @running = false
+    # Push the queue to allow the thread to run and shutdown
+    @thread_queue << nil
+  end
+
+  # Kill the worker thread
+  def join
+    Cosmos.kill_thread(self, @thread)
+  end
+
+  # Call shutdown to gracefully shutdown the worker thread
+  def graceful_kill
+    shutdown()
+  end
+
+  protected
+
+  # @return [Boolean] Whether the value is Not A Number (nan)
+  def nan_value?(value)
+    value.is_a?(Float) && (value.nan? || !value.finite?)
+  end
+
+  # Remove the job from the @locked_tables and add the worker thread back
+  # to the @master_queue so additional jobs can be scheduled
+  #
+  # @param job_type [Symbol] One of :MINUTE, :HOUR, or :DAY
+  # @param packet_config_id [Integer] PacketConfig ID from the database
+  # @param table_index [Integer] Table index used in table names
+  def complete_job(job_type, packet_config_id, table_index)
+    @mutex.synchronize do
+      @locked_tables.delete([job_type, packet_config_id, table_index])
+    end
+    @master_queue << @thread_queue
+  end
+
+  # Get various attributes associated with a job type
+  #
+  # @param job_type [Symbol] One of :MINUTE, :HOUR, or :DAY
+  # @return [Array<Float, String, Symbol>] Array of three items: Float time delta
+  #   which is the number of seconds in the time period, String database model time
+  #   column name, and Symbol method to call on the resulting Ruby Time object to
+  #   get the minute, hour, or day.
+  def job_attributes(job_type)
+    case job_type
+    when :MINUTE
+      return 60.0, "time", :min
+    when :HOUR
+      return 3600.0, "start_time", :hour
+    when :DAY
+      return 86400.0, "start_time", :yday
+    else # Should never get this since we control the jobs so raise
+      raise "Reducer Thread Unexpected Job Type: #{job_type}"
+    end
+  end
+end