cosmos 5.0.2.pre.beta2 → 5.0.4

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
@@ -51,24 +52,6 @@ module Cosmos
     def deploy(gem_path, variables)
       seed_database()
 
-      # Cleanup Microservice
-      microservice_name = "#{@scope}__CLEANUP__S3"
-      microservice = MicroserviceModel.new(
-        name: microservice_name,
-        cmd: ["ruby", "cleanup_microservice.rb", microservice_name],
-        work_dir: '/cosmos/lib/cosmos/microservices',
-        options: [
-          ["SIZE", "20_000_000_000"], # Max Size to keep in S3
-          ["DELAY", "300"], # Delay between size checks
-          ["BUCKET", "logs"], # Bucket to monitor
-          ["PREFIX", @scope + "/"], # Path into bucket to monitor
-        ],
-        scope: @scope
-      )
-      microservice.create
-      microservice.deploy(gem_path, variables)
-      Logger.info "Configured microservice #{microservice_name}"
-
       # COSMOS Log Microservice
       microservice_name = "#{@scope}__COSMOS__LOG"
       microservice = MicroserviceModel.new(
@@ -105,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,
@@ -125,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,
@@ -146,8 +129,6 @@ module Cosmos
     end
 
     def undeploy
-      model = MicroserviceModel.get_model(name: "#{@scope}__CLEANUP__S3", scope: @scope)
-      model.destroy if model
       model = MicroserviceModel.get_model(name: "#{@scope}__COSMOS__LOG", scope: @scope)
       model.destroy if model
       model = MicroserviceModel.get_model(name: "#{@scope}__NOTIFICATION__LOG", scope: @scope)
@@ -159,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

data/lib/cosmos/models/settings_model.rb

@@ -0,0 +1,55 @@
+# 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
+
+require 'cosmos/models/model'
+
+module Cosmos
+  class SettingsModel < Model
+    PRIMARY_KEY = 'cosmos__settings'
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope: nil)
+      super(PRIMARY_KEY, name: name)
+    end
+
+    def self.names(scope: nil)
+      super(PRIMARY_KEY)
+    end
+
+    def self.all(scope: nil)
+      super(PRIMARY_KEY)
+    end
+    # END NOTE
+
+    def initialize(name:, scope: nil, data:)
+      super(PRIMARY_KEY, name: name, scope: scope)
+      @data = data
+    end
+
+    # @return [Hash] JSON encoding of this model
+    def as_json
+      {
+        'name' => @name,
+        'data' => @data,
+        'updated_at' => @updated_at
+      }
+    end
+  end
+end

data/lib/cosmos/models/sorted_model.rb

@@ -0,0 +1,165 @@
+# 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
+# https://redis.io/docs/manual/data-types/data-types-tutorial/#sorted-sets
+
+require 'cosmos/models/model'
+require 'cosmos/topics/calendar_topic'
+
+module Cosmos
+  # Put these under the Cosmos module so they are easily accessed in the controller as
+  # Cosmos::SortedError vs Cosmos::SortedModel::Error
+  class SortedError < StandardError; end
+  class SortedInputError < SortedError; end
+  class SortedOverlapError < SortedError; end
+
+  class SortedModel < Model
+    SORTED_TYPE = 'sorted'.freeze # To be overriden by base class
+    PRIMARY_KEY = '__SORTED'.freeze # To be overriden by base class
+
+    # MUST be overriden by any subclasses
+    def self.pk(scope)
+      "#{scope}#{PRIMARY_KEY}"
+    end
+
+    # @return [String|nil] String of the saved json or nil if start not found
+    def self.get(start:, scope:)
+      result = Store.zrangebyscore(self.pk(scope), start, start)
+      return JSON.parse(result[0]) unless result.empty?
+      nil
+    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)
+      result = Store.zrevrangebyscore(self.pk(scope), '+inf', '-inf', limit: [0, limit])
+      result.map { |item| JSON.parse(item) }
+    end
+
+    # @return [String|nil] json or nil if metadata empty
+    def self.get_current_value(scope:)
+      start = Time.now.to_i
+      array = Store.zrevrangebyscore(self.pk(scope), start, '-inf', limit: [0, 1])
+      return nil if array.empty?
+      return array[0]
+    end
+
+    # @param start [Integer] Start time to return values (inclusive)
+    # @param stop [Integer] Stop time to return values (inclusive)
+    # @return [Array|nil] Array up to 100 of this model or empty array
+    def self.range(start:, stop:, scope:, limit: 100)
+      if start > stop
+        raise SortedInputError.new "start: #{start} must be before stop: #{stop}"
+      end
+      result = Store.zrangebyscore(self.pk(scope), start, stop, limit: [0, limit])
+      result.map { |item| JSON.parse(item) }
+    end
+
+    # @return [Integer] count of the members stored under the primary key
+    def self.count(scope:)
+      Store.zcard(self.pk(scope))
+    end
+
+    # Remove member from a sorted set
+    # @return [Integer] count of the members removed, 0 if not found
+    def self.destroy(scope:, start:)
+      Store.zremrangebyscore(self.pk(scope), start, start)
+    end
+
+    # Remove members from min to max of the sorted set.
+    # @return [Integer] count of the members removed
+    def self.range_destroy(scope:, start:, stop:)
+      Store.zremrangebyscore(self.pk(scope), start, stop)
+    end
+
+    attr_reader :start
+
+    # @param [Integer] start - start used to store data
+    # @param [String] scope - Cosmos scope to track event to
+    # @param [Anything] kwargs - Any kwargs to store in the JSON
+    def initialize(start:, scope:, type: SORTED_TYPE, **kwargs)
+      # Name becomes the start in the base class
+      super(self.class.pk(scope), name: start.to_s, scope: scope, **kwargs)
+      @type = type # For the as_json, from_json round trip
+      @start = start
+    end
+
+    # start MUST be a positive integer
+    def validate_start(update: false)
+      unless @start.is_a?(Integer)
+        raise SortedInputError.new "start must be integer: #{@start}"
+      end
+      if @start.to_i < 0
+        raise SortedInputError.new "start must be positive: #{@start}"
+      end
+      if !update and self.class.get(start: @start, scope: @scope)
+        raise SortedOverlapError.new "duplicate, existing data at #{@start}"
+      end
+      @start = @start.to_i
+    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_start(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:)
+      @start = start
+      create(update: true)
+    end
+
+    # destroy the activity from the redis database
+    def destroy
+      self.class.destroy(scope: @scope, 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 SortedError.new "Failed to write to stream: #{notification}, #{e}"
+      end
+    end
+
+    # @return [Hash] JSON encoding of this model
+    def as_json
+      { **super(),
+        'start' => @start,
+        'type' => SORTED_TYPE,
+      }
+    end
+  end
+end