cosmos 5.0.2.pre.beta2 → 5.0.4

data/lib/cosmos/utilities/store_autoload.rb

@@ -31,7 +31,7 @@ end
 module Cosmos
   class Store
     # Variable that holds the singleton instance
-    @@instance = nil
+    @instance = nil
 
     # Mutex used to ensure that only one instance is created
     @@instance_mutex = Mutex.new
@@ -42,11 +42,11 @@ module Cosmos
     # Get the singleton instance
     def self.instance(pool_size = 100)
       # Logger.level = Logger::DEBUG
-      return @@instance if @@instance
+      return @instance if @instance
 
       @@instance_mutex.synchronize do
-        @@instance ||= self.new(pool_size)
-        return @@instance
+        @instance ||= self.new(pool_size)
+        return @instance
       end
     end
 
@@ -87,44 +87,10 @@ module Cosmos
       end
     end
 
-    def get_cmd_item(target_name, packet_name, param_name, type: :WITH_UNITS, scope: $cosmos_scope)
-      msg_id, msg_hash = read_topic_last("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
-      if msg_id
-        # TODO: We now have these reserved items directly on command packets
-        # Do we still calculate from msg_hash['time'] or use the times directly?
-        #
-        # if param_name == 'RECEIVED_TIMESECONDS' || param_name == 'PACKET_TIMESECONDS'
-        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).to_f
-        # elsif param_name == 'RECEIVED_TIMEFORMATTED' || param_name == 'PACKET_TIMEFORMATTED'
-        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).formatted
-        if param_name == 'RECEIVED_COUNT'
-          msg_hash['received_count'].to_i
-        else
-          json = msg_hash['json_data']
-          hash = JSON.parse(json)
-          # Start from the most complex down to the basic raw value
-          value = hash["#{param_name}__U"]
-          return value if value && type == :WITH_UNITS
-
-          value = hash["#{param_name}__F"]
-          return value if value && (type == :WITH_UNITS || type == :FORMATTED)
-
-          value = hash["#{param_name}__C"]
-          return value if value && (type == :WITH_UNITS || type == :FORMATTED || type == :CONVERTED)
-
-          return hash[param_name]
-        end
-      end
-    end
-
     ###########################################################################
     # Stream APIs
     ###########################################################################
 
-    def self.initialize_streams(topics)
-      self.instance.initialize_streams(topics)
-    end
-
     def initialize_streams(topics)
       @redis_pool.with do |redis|
         topics.each do |topic|
@@ -134,48 +100,18 @@ module Cosmos
       end
     end
 
-    def self.get_oldest_message(topic)
-      self.instance.get_oldest_message(topic)
-    end
-
     def get_oldest_message(topic)
       @redis_pool.with do |redis|
         result = redis.xrange(topic, count: 1)
-        return result[0]
-      end
-    end
-
-    def self.get_newest_message(topic)
-      self.instance.get_newest_message(topic)
-    end
-
-    def get_newest_message(topic)
-      @redis_pool.with do |redis|
-        result = redis.xrevrange(topic, count: 1)
-        return result[0]
-      end
-    end
-
-    def self.get_last_offset(topic)
-      self.instance.get_last_offset(topic)
-    end
-
-    def get_last_offset(topic)
-      @redis_pool.with do |redis|
-        result = redis.xrevrange(topic, count: 1)
-        if result and result[0] and result[0][0]
-          result[0][0]
+        if result and result.length > 0
+          return result[0]
         else
-          "0-0"
+          return nil
         end
       end
     end
 
-    def self.read_topic_last(topic)
-      self.instance.read_topic_last(topic)
-    end
-
-    def read_topic_last(topic)
+    def get_newest_message(topic)
       @redis_pool.with do |redis|
         # Default in xrevrange is range end '+', start '-' which means get all
         # elements from higher ID to lower ID and since we're limiting to 1
@@ -189,18 +125,15 @@ module Cosmos
       end
     end
 
-    # TODO: Currently unused
-    # def decrement_id(id)
-    #   time, sequence = id.split('-')
-    #   if sequence == '0'
-    #     "#{time.to_i - 1}-18446744073709551615"
-    #   else
-    #     "#{time}-#{sequence.to_i - 1}"
-    #   end
-    # end
-
-    def self.update_topic_offsets(topics)
-      self.instance.update_topic_offsets(topics)
+    def get_last_offset(topic)
+      @redis_pool.with do |redis|
+        result = redis.xrevrange(topic, count: 1)
+        if result and result[0] and result[0][0]
+          result[0][0]
+        else
+          "0-0"
+        end
+      end
     end
 
     def update_topic_offsets(topics)
@@ -221,15 +154,12 @@ module Cosmos
       return offsets
     end
 
-    def self.read_topics(topics, offsets = nil, timeout_ms = 1000, &block)
-      self.instance.read_topics(topics, offsets, timeout_ms, &block)
-    end
     unless $enterprise_cosmos
-      def read_topics(topics, offsets = nil, timeout_ms = 1000)
+      def read_topics(topics, offsets = nil, timeout_ms = 1000, count = nil)
         # Logger.debug "read_topics: #{topics}, #{offsets} pool:#{@redis_pool}"
         @redis_pool.with do |redis|
           offsets = update_topic_offsets(topics) unless offsets
-          result = redis.xread(topics, offsets, block: timeout_ms)
+          result = redis.xread(topics, offsets, block: timeout_ms, count: count)
           if result and result.length > 0
             result.each do |topic, messages|
               messages.each do |msg_id, msg_hash|
@@ -244,26 +174,6 @@ module Cosmos
       end
     end
 
-    # Add new entry to the redis stream.
-    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
-    #
-    # @example Without options
-    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'})
-    # @example With options
-    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'}, id: '0-0', maxlen: 1000, approximate: false)
-    #
-    # @param topic [String] the stream / topic
-    # @param msg_hash [Hash]   one or multiple field-value pairs
-    #
-    # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation
-    # @option opts [Integer] :maxlen      max length of entries
-    # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
-    #
-    # @return [String] the entry id
-    def self.write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = true)
-      self.instance.write_topic(topic, msg_hash, id, maxlen, approximate)
-    end
-
     # Add new entry to the redis stream.
     # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
     #
@@ -289,23 +199,6 @@ module Cosmos
       end
     end
 
-    # Trims older entries of the redis stream if needed.
-    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
-    #
-    # @example Without options
-    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000)
-    # @example With options
-    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000, approximate: true, limit: 0)
-    #
-    # @param topic  [String]  the stream key
-    # @param minid  [Integer] max length of entries to trim
-    # @param limit  [Boolean] whether to add `~` modifier of maxlen or not
-    #
-    # @return [Integer] the number of entries actually deleted
-    def self.trim_topic(topic, minid, approximate = true, limit: 0)
-      self.instance.trim_topic(topic, minid, approximate, limit: limit)
-    end
-
     # Trims older entries of the redis stream if needed.
     # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
     #
@@ -324,15 +217,13 @@ module Cosmos
         return redis.xtrim_minid(topic, minid, approximate: approximate, limit: limit)
       end
     end
+  end
 
-    # Execute any Redis command. Args must be an array (e.g. ["KEYS", "*"])
-    def self.execute_raw(args)
-      self.instance.execute_raw(args)
-    end
-
-    # Execute any Redis command. Args must be an array (e.g. ["KEYS", "*"])
-    def execute_raw(args)
-      synchronize { |client| client.call(args) }
+  class EphemeralStore < Store
+    def initialize(pool_size = 10)
+      super(pool_size)
+      @redis_url = "redis://#{ENV['COSMOS_REDIS_EPHEMERAL_HOSTNAME']}:#{ENV['COSMOS_REDIS_EPHEMERAL_PORT']}"
+      @redis_pool = ConnectionPool.new(size: pool_size) { build_redis() }
     end
   end
 end

data/lib/cosmos/version.rb

@@ -1,13 +1,14 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '5.0.2-beta2'
+COSMOS_VERSION = '5.0.4'
 module Cosmos
   module Version
     MAJOR = '5'
     MINOR = '0'
-    PATCH = '2'
-    OTHER = 'beta2'
-    BUILD = '86e4fc1b82d7941b7f77e9257ecafafeff9fe3fd'
+    PATCH = '4'
+    OTHER = ''
+    BUILD = '84d6dcebd4bc21e5559963be4e5fde2ddb7e9822'
   end
-  VERSION = '5.0.2-beta2'
+  VERSION = '5.0.4'
+  GEM_VERSION = '5.0.4'
 end

data/templates/plugin-template/plugin.gemspec

@@ -20,6 +20,4 @@ spec = Gem::Specification.new do |s|
     s.version = '0.0.0' + ".#{time}"
   end
   s.files = Dir.glob("{targets,lib,procedures,tools,microservices}/**/*") + %w(Rakefile README.md plugin.txt)
-
-  s.add_runtime_dependency 'cosmos', '~> 5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cosmos
 version: !ruby/object:Gem::Version
-  version: 5.0.2.pre.beta2
+  version: 5.0.4
 platform: ruby
 authors:
 - Ryan Melton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-28 00:00:00.000000000 Z
+date: 2022-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -693,7 +693,7 @@ files:
 - lib/cosmos/models/microservice_model.rb
 - lib/cosmos/models/microservice_status_model.rb
 - lib/cosmos/models/model.rb
-- lib/cosmos/models/narrative_model.rb
+- lib/cosmos/models/note_model.rb
 - lib/cosmos/models/notification_model.rb
 - lib/cosmos/models/ping_model.rb
 - lib/cosmos/models/plugin_model.rb
@@ -703,8 +703,11 @@ files:
 - lib/cosmos/models/router_model.rb
 - lib/cosmos/models/router_status_model.rb
 - lib/cosmos/models/scope_model.rb
+- lib/cosmos/models/settings_model.rb
+- lib/cosmos/models/sorted_model.rb
 - lib/cosmos/models/target_model.rb
 - lib/cosmos/models/timeline_model.rb
+- lib/cosmos/models/tool_config_model.rb
 - lib/cosmos/models/tool_model.rb
 - lib/cosmos/models/trigger_group_model.rb
 - lib/cosmos/models/trigger_model.rb
@@ -833,11 +836,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.5
+rubygems_version: 3.3.14
 signing_key:
 specification_version: 4
 summary: Ball Aerospace COSMOS

data/lib/cosmos/models/narrative_model.rb

@@ -1,280 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2022 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 Affero General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-#
-# 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.  See the
-# GNU Affero General Public License for more details.
-#
-# This program may also be used under the terms of a commercial or
-# enterprise edition license of COSMOS if purchased from the
-# copyright holder
-
-# https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
-
-require 'cosmos/topics/calendar_topic'
-
-module Cosmos
-
-  class NarrativeError < StandardError; end
-
-  class NarrativeInputError < NarrativeError; end
-
-  class NarrativeOverlapError < NarrativeError; end
-
-  class NarrativeModel < Model
-
-    CHRONICLE_TYPE = 'narrative'.freeze
-    PRIMARY_KEY = '__NARRATIVE'.freeze
-    
-    def self.pk(scope)
-      return "#{scope}#{PRIMARY_KEY}"
-    end
-  
-    # @return [Array|nil] Array up to 100 of this model or empty array
-    def self.get(start:, stop:, scope:, limit: 100)
-      if start > stop
-        raise MetadataInputError.new "start: #{start} must be before stop: #{stop}"
-      end
-      pk = self.pk(scope)
-      array = Store.zrangebyscore(pk, start, stop, :limit => [0, limit])
-      ret_array = Array.new
-      array.each do |value|
-        ret_array << JSON.parse(value)
-      end
-      return ret_array
-    end
-
-    # @return [Array<Hash>] Array up to the limit of the models (as Hash objects) stored under the primary key
-    def self.all(scope:, limit: 100)
-      pk = self.pk(scope) 
-      array = Store.zrange(pk, 0, -1, :limit => [0, limit])
-      ret_array = Array.new
-      array.each do |value|
-        ret_array << JSON.parse(value)
-      end
-      return ret_array
-    end
-
-    # @return [Integer] count of the members stored under the primary key
-    def self.count(scope:)
-      return Store.zcard(self.pk(scope))
-    end
-
-    # @return [String|nil] String of the saved json or nil if score not found under primary_key
-    def self.score(score:, scope:)
-      pk = self.pk(scope) 
-      array = Store.zrangebyscore(pk, score, score, :limit => [0, 1])
-      array.each do |value|
-        return JSON.parse(value)
-      end
-      return nil
-    end
-
-    # Remove member from a sorted set based on the score.
-    # @return [Integer] count of the members removed
-    def self.destroy(scope:, score:)
-      pk = self.pk(scope) 
-      Store.zremrangebyscore(pk, score, score)
-    end
-
-    # Remove members from min to max of the sorted set.
-    # @return [Integer] count of the members removed
-    def self.range_destroy(scope:, min:, max:)
-      pk = self.pk(scope) 
-      Store.zremrangebyscore(pk, min, max)
-    end
-
-    # @return [NarrativeModel] Model generated from the passed JSON
-    def self.from_json(json, scope:)
-      json = JSON.parse(json) if String === json
-      raise "json data is nil" if json.nil?
-
-      json.transform_keys!(&:to_sym)
-      self.new(**json, scope: scope)
-    end
-
-    attr_reader :start, :stop, :duration, :color, :description, :type
-
-    # @param [String] scope - Cosmos scope to track event to
-    # @param [Integer] start - start of the event in seconds from Epoch
-    # @param [Integer] stop - stop of the event in seconds from Epoch
-    # @param [String] color - The event color
-    # @param [String] description - What the event is about
-    def initialize(
-      scope:,
-      start:,
-      stop:,
-      color:,
-      description:,
-      type: CHRONICLE_TYPE,
-      updated_at: 0,
-      duration: 0
-    )
-      super(NarrativeModel.pk(scope), name: start.to_s, scope: scope)
-      set_input(
-        start: start,
-        stop: stop,
-        color: color,
-        description: description,
-      )
-      @type = type
-      @updated_at = updated_at
-    end
-
-    # validate color
-    def validate_color(color)
-      if color.nil?
-        color = '#%06x' % (rand * 0xffffff)
-      end
-      valid_color = color =~ /(#*)([0-9,a-f,A-f]{6})/
-      if valid_color.nil?
-        raise MetadataInputError.new "invalid color but in hex format. #FF0000"
-      end
-
-      color = "##{color}" unless color.start_with?('#')
-      return color
-    end
-
-    # validate the input to the rules we have created for timelines.
-    # - An entry's start MUST be before the stop.
-    # - An entry's description MUST a String.
-    def validate_input(start:, stop:, color:, description:)
-      begin
-        DateTime.strptime(start.to_s, '%s')
-        DateTime.strptime(stop.to_s, '%s')
-      rescue Date::Error
-        raise NarrativeInputError.new "failed validation input must be seconds: #{start}, #{stop}"
-      end
-      validate_color(color)
-      duration = stop - start
-      if duration <= 0
-        raise NarrativeInputError.new "start: #{start} must be before stop: #{stop}"
-      elsif description.is_a?(String) == false
-        raise NarrativeInputError.new "description must be a String: #{description}"
-      end
-    end
-
-    # Set the values of the instance, @start, @stop, @description...
-    def set_input(start:, stop:, color:, description:)
-      begin
-        DateTime.strptime(start.to_s, '%s')
-        DateTime.strptime(stop.to_s, '%s')
-      rescue ArgumentError
-        raise NarrativeInputError.new "invalid input must be seconds: #{start}, #{stop}"
-      end
-      @start = start
-      @stop = stop
-      @duration = @stop - @start
-      @color = color
-      @description = description
-    end
-
-    # validate_time will be called on create and update this will validate
-    # that no other chronicle event or metadata had been saved for that time.
-    # One event or metadata per second to ensure data can be updated.
-    #
-    # @param [Integer] ignore_score - should be nil unless you want to ignore
-    #   a time when doing an update
-    def validate_time(ignore_score: nil)
-      array = Store.zrangebyscore(@primary_key, @start, @start, :limit => [0, 1])
-      array.each do |value|
-        entry = JSON.parse(value)
-        if ignore_score == entry['start']
-          next
-        else
-          return entry
-        end
-      end
-      return nil
-    end
-
-    # Update the Redis hash at primary_key and set the score equal to the start Epoch time
-    # the member is set to the JSON generated via calling as_json
-    def create
-      validate_input(start: @start, stop: @stop, color: @color, description: @description)
-      collision = validate_time()
-      unless collision.nil?
-        raise NarrativeOverlapError.new "no chronicles can overlap, collision: #{collision}"
-      end
-
-      @updated_at = Time.now.to_nsec_from_epoch
-      Store.zadd(@primary_key, @start, JSON.generate(as_json()))
-      notify(kind: 'created')
-    end
-
-    # Update the Redis hash at primary_key and remove the current activity at the current score
-    # and update the score to the new score equal to the start Epoch time this uses a multi
-    # to execute both the remove and create. The member via the JSON generated via calling as_json
-    def update(start:, stop:, color:, description:)
-      validate_input(start: start, stop: stop, color: color, description: description)
-      old_start = @start
-
-      set_input(
-        start: start,
-        stop: stop,
-        color: color,
-        description: description,
-      )
-      @updated_at = Time.now.to_nsec_from_epoch
-
-      collision = validate_time(ignore_score: old_start)
-      unless collision.nil?
-        raise NarrativeOverlapError.new "failed to update #{old_start}, no chronicles can overlap, collision: #{collision}"
-      end
-
-      Store.multi do |multi|
-        multi.zremrangebyscore(@primary_key, old_start, old_start)
-        multi.zadd(@primary_key, @start, JSON.generate(as_json()))
-      end
-      notify(kind: 'updated', extra: old_start)
-      return @start
-    end
-
-    # destroy the activity from the redis database
-    def destroy
-      Store.zremrangebyscore(@primary_key, @start, @start)
-      notify(kind: 'deleted')
-    end
-
-    # @return [] update the redis stream / timeline topic that something has changed
-    def notify(kind:, extra: nil)
-      notification = {
-        'data' => JSON.generate(as_json()),
-        'kind' => kind,
-        'type' => 'calendar',
-      }
-      notification['extra'] = extra unless extra.nil?
-      begin
-        CalendarTopic.write_entry(notification, scope: @scope)
-      rescue StandardError => e
-        raise NarrativeError.new "Failed to write to stream: #{notification}, #{e}"
-      end
-    end
-
-    # @return [Hash] generated from the NarrativeModel
-    def as_json
-      return {
-        'color' => @color,
-        'start' => @start,
-        'stop' => @stop,
-        'description' => @description,
-        'type' => CHRONICLE_TYPE,
-        'scope' => @scope,
-        'updated_at' => @updated_at,
-      }
-    end
-
-    # @return [String] string view of NarrativeModel
-    def to_s
-      return "<NarrativeModel ->: #{@start}, x: #{@stop}, c: #{@color}, d: #{@description}>"
-    end
-  end
-end