cosmos 5.0.3 → 5.0.4

data/lib/cosmos/models/metadata_model.rb

@@ -19,271 +19,97 @@
 
 # https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
 
-require 'cosmos/topics/calendar_topic'
+require 'cosmos/models/sorted_model'
 
 module Cosmos
-
-  class MetadataError < StandardError; end
-
-  class MetadataInputError < MetadataError; end
-
-  class MetadataOverlapError < MetadataError; end
-
-  class MetadataModel < Model
-
-    CHRONICLE_TYPE = 'metadata'.freeze
-    CURRENT_VALUE = '__current.metadata.value'.freeze
+  class MetadataModel < SortedModel
+    METADATA_TYPE = 'metadata'.freeze
     PRIMARY_KEY = '__METADATA'.freeze
 
     def self.pk(scope)
-      return "#{scope}#{PRIMARY_KEY}"
-    end
-
-    # @return [String|nil] String of the saved json or nil if score not found under current value
-    def self.get_current_value(target:, scope:)
-      json = Store.hget("#{scope}#{CURRENT_VALUE}", target)
-      return nil unless json
-      return self.from_json(JSON.parse(json), scope: scope)
-    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))
+      "#{scope}#{PRIMARY_KEY}"
     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 [MetadataModel] 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 :target, :start, :color, :metadata, :type
+    attr_reader :color, :metadata, :type
 
-    # @param [String] target - should be the target but can be anything
     # @param [Integer] start - time metadata is active in seconds from Epoch
     # @param [String] color - The event color
     # @param [String] metadata - Key value pair object to link to name
     # @param [String] scope - Cosmos scope to track event to
     def initialize(
-      target:,
+      scope:,
       start:,
       color: nil,
       metadata:,
-      scope:,
-      type: CHRONICLE_TYPE,
+      type: METADATA_TYPE,
       updated_at: 0
     )
-      super(MetadataModel.pk(scope), name: start.to_s, scope: scope)
-      set_input(start: start, color: color, metadata: metadata)
-      @target = target
-      @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, must be in hex format, e.g. #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 valid.
-    # - An entry's start MUST NOT be in the future.
-    # - An entry's metadata MUST a hash/object.
-    def validate_input(start:, color:, metadata:)
-      if start.is_a?(Integer) == false
-        raise MetadataInputError.new "failed validation input must be integer: #{start}"
-      end
-      now = Time.now.strftime('%s%3N').to_i
-      if start > now
-        raise MetadataInputError.new "start can not be in the future: #{start} > #{now}"
-      end
-      validate_color(color)
-      if metadata.is_a?(Hash) == false
-        raise MetadataInputError.new "Metadata must be a hash/object: #{metadata}"
-      end
-    end
-
-    # Set the values of the instance, @start, @stop, @metadata...
-    def set_input(start:, color:, metadata:)
-      if start.is_a?(Integer) == false
-        raise MetadataInputError.new "start input must be integer: #{start}"
-      end
+      super(start: start, scope: scope, updated_at: updated_at)
       @start = start
       @color = color
       @metadata = metadata
+      @type = type # For the as_json, from_json round trip
     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
+    # Validates the instance variables: @start, @color, @metadata
+    def validate(update: false)
+      validate_start(update: update)
+      validate_color()
+      validate_metadata()
     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, color: @color, metadata: @metadata)
-      collision = validate_time()
-      unless collision.nil?
-        raise MetadataOverlapError.new "no chronicle can overlap, collision: #{collision}"
+    def validate_color()
+      if @color.nil?
+        @color = '#%06x' % (rand * 0xffffff)
       end
-
-      @updated_at = Time.now.to_nsec_from_epoch
-      Store.zadd(@primary_key, @start, JSON.generate(as_json()))
-      update_current_value()
-      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:, color:, metadata:)
-      validate_input(start: start, color: color, metadata: metadata)
-      old_start = @start
-      @updated_at = Time.now.to_nsec_from_epoch
-      set_input(start: start, color: color, metadata: metadata)
-      # copy of create
-      collision = validate_time(ignore_score: old_start)
-      unless collision.nil?
-        raise MetadataOverlapError.new "failed to update #{old_start}, no chronicles can overlap, collision: #{collision}"
+      unless @color =~ /(#*)([0-9,a-f,A-f]{6})/
+        raise SortedInputError.new "invalid color, must be in hex format, e.g. #FF0000"
       end
+      @color = "##{@color}" unless @color.start_with?('#')
+    end
 
-      Store.multi do |multi|
-        multi.zremrangebyscore(@primary_key, old_start, old_start)
-        multi.zadd(@primary_key, @start, JSON.generate(as_json()))
+    def validate_metadata()
+      unless @metadata.is_a?(Hash)
+        raise SortedInputError.new "Metadata must be a hash/object: #{@metadata}"
       end
-      update_current_value(old_start: old_start)
-      notify(kind: 'updated', extra: old_start)
-      return @start
     end
 
-    # Update the Redis hash at primary_key and check if this metadata instance
-    # is newer than the current instance stored in the hash. If the hash does
-    # NOT contain an instance or this metadata instance is newer it will update
-    # the current hash.
-    def update_current_value(old_start: nil)
-      update = true
-      json = Store.hget("#{@scope}#{CURRENT_VALUE}", @target)
-      unless json.nil?
-        model = MetadataModel.from_json(JSON.parse(json), scope: @scope)
-        update = model.start <= @start || model.start == old_start
-      end
+    # Update the Redis hash at primary_key based on the initial passed start
+    # The member is set to the JSON generated via calling as_json
+    def create(update: false)
+      validate(update: update)
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.zadd(@primary_key, @start, JSON.generate(as_json()))
       if update
-        return Store.hset("#{@scope}#{CURRENT_VALUE}", @target, JSON.generate(as_json()))
+        notify(kind: 'updated')
+      else
+        notify(kind: 'created')
       end
     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 MetadataError.new "Failed to write to stream: #{notification}, #{e}"
-      end
+    # Update the Redis hash at primary_key
+    def update(start:, color:, metadata:)
+      @start = start
+      @color = color
+      @metadata = metadata
+      create(update: true)
     end
 
     # @return [Hash] generated from the MetadataModel
     def as_json
       return {
-        'target' => @target,
         'scope' => @scope,
-        'updated_at' => @updated_at,
         'start' => @start,
         'color' => @color,
         'metadata' => @metadata,
-        'type' => CHRONICLE_TYPE,
+        'type' => METADATA_TYPE,
+        'updated_at' => @updated_at,
       }
     end
 
     # @return [String] string view of metadata
     def to_s
-      return "<MetadataModel t: #{@target}, s: #{@start}, c: #{@color}, m: #{@metadata}>"
+      return "<MetadataModel s: #{@start}, c: #{@color}, m: #{@metadata}>"
     end
   end
 end

data/lib/cosmos/models/metric_model.rb

@@ -20,7 +20,7 @@
 require 'cosmos/models/model'
 
 module Cosmos
-  class MetricModel < Model
+  class MetricModel < EphemeralModel
     PRIMARY_KEY = '__cosmos__metric'.freeze
 
     # NOTE: The following three class methods are used by the ModelController
@@ -38,7 +38,7 @@ module Cosmos
     end
 
     def self.destroy(scope:, name:)
-      Store.hdel("#{scope}#{PRIMARY_KEY}", name)
+      EphemeralStore.hdel("#{scope}#{PRIMARY_KEY}", name)
     end
 
     def initialize(name:, scope:, metric_name:, label_list:)

data/lib/cosmos/models/microservice_model.rb

@@ -186,7 +186,7 @@ module Cosmos
         # Load microservice files
         data = File.read(filename, mode: "rb")
         Cosmos.set_working_dir(File.dirname(filename)) do
-          data = ERB.new(data).result(binding.set_variables(variables)) if data.is_printable?
+          data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable?
         end
         rubys3_client.put_object(bucket: 'config', key: key, body: data)
       end

data/lib/cosmos/models/microservice_status_model.rb

@@ -20,7 +20,7 @@
 require 'cosmos/models/model'
 
 module Cosmos
-  class MicroserviceStatusModel < Model
+  class MicroserviceStatusModel < EphemeralModel
     PRIMARY_KEY = 'cosmos_microservice_status'
 
     attr_accessor :state

data/lib/cosmos/models/model.rb

@@ -27,12 +27,16 @@ module Cosmos
     attr_accessor :plugin
     attr_accessor :scope
 
+    def self.store
+      Store
+    end
+
     # NOTE: The following three methods must be reimplemented by Model subclasses
     # without primary_key to support other class methods.
 
     # @return [Hash|nil] Hash of this model or nil if name not found under primary_key
     def self.get(primary_key, name:)
-      json = Store.hget(primary_key, name)
+      json = store.hget(primary_key, name)
       if json
         return JSON.parse(json)
       else
@@ -42,12 +46,12 @@ module Cosmos
 
     # @return [Array<String>] All the names stored under the primary key
     def self.names(primary_key)
-      Store.hkeys(primary_key).sort
+      store.hkeys(primary_key).sort
     end
 
     # @return [Array<Hash>] All the models (as Hash objects) stored under the primary key
     def self.all(primary_key)
-      hash = Store.hgetall(primary_key)
+      hash = store.hgetall(primary_key)
       hash.each do |key, value|
         hash[key] = JSON.parse(value)
       end
@@ -117,16 +121,6 @@ module Cosmos
       raise "must be implemented by subclass"
     end
 
-    # TODO: Not used
-    # def self.from_config(primary_key, filename)
-    #   model = nil
-    #   parser = ConfigParser.new
-    #   parser.parse_file(filename) do |keyword, parameters|
-    #     model = self.handle_config(primary_key, parser, model, keyword, parameters)
-    #   end
-    #   model
-    # end
-
     # Store the primary key and keyword arguments
     def initialize(primary_key, **kw_args)
       @primary_key = primary_key
@@ -140,7 +134,7 @@ module Cosmos
     # to the JSON generated via calling as_json
     def create(update: false, force: false)
       unless force
-        existing = Store.hget(@primary_key, @name)
+        existing = self.class.store.hget(@primary_key, @name)
         if existing
           raise "#{@primary_key}:#{@name} already exists at create" unless update
         else
@@ -148,7 +142,7 @@ module Cosmos
         end
       end
       @updated_at = Time.now.to_nsec_from_epoch
-      Store.hset(@primary_key, @name, JSON.generate(self.as_json))
+      self.class.store.hset(@primary_key, @name, JSON.generate(self.as_json))
     end
 
     # Alias for create(update: true)
@@ -170,7 +164,7 @@ module Cosmos
     # Delete the model from the Store
     def destroy
       undeploy()
-      Store.hdel(@primary_key, @name)
+      self.class.store.hdel(@primary_key, @name)
     end
 
     # @return [Hash] JSON encoding of this model
@@ -186,4 +180,10 @@ module Cosmos
       ""
     end
   end
+
+  class EphemeralModel < Model
+    def self.store
+      EphemeralStore
+    end
+  end
 end

data/lib/cosmos/models/note_model.rb

@@ -0,0 +1,124 @@
+# 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/models/sorted_model'
+
+module Cosmos
+  class NoteModel < SortedModel
+    NOTE_TYPE = 'note'.freeze
+    PRIMARY_KEY = '__NOTE'.freeze
+
+    def self.pk(scope)
+      "#{scope}#{PRIMARY_KEY}"
+    end
+
+    attr_reader :stop, :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: nil,
+      description:,
+      type: NOTE_TYPE,
+      updated_at: 0
+    )
+      super(start: start, scope: scope, updated_at: updated_at)
+      @start = start
+      @stop = stop
+      @color = color
+      @description = description
+      @type = type # For the as_json, from_json round trip
+    end
+
+    # Validates the instance variables: @start, @stop, @color, @description
+    def validate(update: false)
+      validate_start(update: update)
+      validate_stop()
+      validate_color()
+    end
+
+    def validate_stop()
+      unless @stop.is_a?(Integer)
+        raise SortedInputError.new "stop must be integer: #{@stop}"
+      end
+      if @stop.to_i < @start
+        raise SortedInputError.new "stop: #{@stop} must be >= start: #{@start}"
+      end
+      @stop = @stop.to_i
+    end
+
+    def validate_color()
+      if @color.nil?
+        @color = '#%06x' % (rand * 0xffffff)
+      end
+      unless @color =~ /(#*)([0-9,a-f,A-f]{6})/
+        raise SortedInputError.new "invalid color, must be in hex format, e.g. #FF0000"
+      end
+      @color = "##{@color}" unless @color.start_with?('#')
+    end
+
+    # Update the Redis hash at primary_key based on the initial passed start
+    # The member is set to the JSON generated via calling as_json
+    def create(update: false)
+      validate(update: update)
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.zadd(@primary_key, @start, JSON.generate(as_json()))
+      if update
+        notify(kind: 'updated')
+      else
+        notify(kind: 'created')
+      end
+    end
+
+    # Update the Redis hash at primary_key
+    def update(start:, stop:, color:, description:)
+      @start = start
+      @stop = stop
+      @color = color
+      @description = description
+      create(update: true)
+    end
+
+    # @return [Hash] generated from the NoteModel
+    def as_json
+      return {
+        'scope' => @scope,
+        'start' => @start,
+        'stop' => @stop,
+        'color' => @color,
+        'description' => @description,
+        'type' => NOTE_TYPE,
+        'updated_at' => @updated_at,
+      }
+    end
+
+    # @return [String] string view of NoteModel
+    def to_s
+      return "<NoteModel s: #{@start}, x: #{@stop}, c: #{@color}, d: #{@description}>"
+    end
+  end
+end

data/lib/cosmos/models/ping_model.rb

@@ -24,7 +24,8 @@ module Cosmos
     # @return String ['UP' or 'DOWN']
     def self.get()
       response = Store.ping()
-      if response
+      response2 = EphemeralStore.ping()
+      if response and response2
         return 'UP'
       else
         return 'DOWN'

data/lib/cosmos/models/plugin_model.rb

@@ -125,7 +125,7 @@ module Cosmos
         gem_file_path = Cosmos::GemModel.get(temp_dir, name)
 
         # Actually install the gem now (slow)
-        Cosmos::GemModel.install(gem_file_path)
+        Cosmos::GemModel.install(gem_file_path, scope: scope)
 
         # Extract gem contents
         gem_path = File.join(temp_dir, "gem")

data/lib/cosmos/models/process_status_model.rb

@@ -21,7 +21,7 @@ require 'cosmos/models/model'
 
 module Cosmos
   # Stores the status about an process.
-  class ProcessStatusModel < Model
+  class ProcessStatusModel < EphemeralModel
     PRIMARY_KEY = 'cosmos_process_status'
 
     attr_accessor :state

data/lib/cosmos/models/scope_model.rb

@@ -20,6 +20,7 @@
 require 'cosmos/version'
 require 'cosmos/models/model'
 require 'cosmos/models/microservice_model'
+require 'cosmos/models/settings_model'
 
 module Cosmos
   class ScopeModel < Model
@@ -87,7 +88,7 @@ module Cosmos
       Logger.info "Configured microservice #{microservice_name}"
 
       # UNKNOWN CommandLog Microservice
-      Store.initialize_streams(["#{@scope}__COMMAND__{UNKNOWN}__UNKNOWN"])
+      Topic.initialize_streams(["#{@scope}__COMMAND__{UNKNOWN}__UNKNOWN"])
       microservice_name = "#{@scope}__COMMANDLOG__UNKNOWN"
       microservice = MicroserviceModel.new(
         name: microservice_name,
@@ -107,7 +108,7 @@ module Cosmos
       Logger.info "Configured microservice #{microservice_name}"
 
       # UNKNOWN PacketLog Microservice
-      Store.initialize_streams(["#{@scope}__TELEMETRY__{UNKNOWN}__UNKNOWN"])
+      Topic.initialize_streams(["#{@scope}__TELEMETRY__{UNKNOWN}__UNKNOWN"])
       microservice_name = "#{@scope}__PACKETLOG__UNKNOWN"
       microservice = MicroserviceModel.new(
         name: microservice_name,
@@ -139,10 +140,12 @@ module Cosmos
     end
 
     def seed_database
-      # Set default values for items in the db that should be set
-      # Use the "nx" (not-exists) variant of redis calls here to not overwrite things the user has already set
-      Cosmos::Store.hsetnx('cosmos__settings', 'source_url', 'https://github.com/BallAerospace/COSMOS')
-      Cosmos::Store.hsetnx('cosmos__settings', 'version', ENV['COSMOS_VERSION'] || COSMOS_VERSION)
+      setting = SettingsModel.get(name: 'source_url')
+      SettingsModel.set({ name: 'source_url', data: 'https://github.com/BallAerospace/COSMOS' }, scope: @scope) unless setting
+    end
+
+    def self.limits_set(scope:)
+      Store.hget("#{scope}__cosmos_system", 'limits_set').intern
     end
   end
 end