cosmos 4.5.2 → 5.0.3

data/lib/cosmos/models/gem_model.rb

@@ -0,0 +1,131 @@
+# 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 'open-uri'
+require 'nokogiri'
+require 'httpclient'
+require 'rubygems'
+require 'rubygems/uninstaller'
+require 'tempfile'
+require 'cosmos/utilities/s3'
+require 'cosmos/utilities/process_manager'
+require 'cosmos/api/api'
+
+module Cosmos
+  # This class acts like a Model but doesn't inherit from Model because it doesn't
+  # actual interact with the Store (Redis). Instead we implement names, get, put
+  # and destroy to allow interaction with gem files from the PluginModel and
+  # the GemsController.
+  class GemModel
+    extend Api
+
+    @@bucket_initialized = false
+
+    def self.names
+      rubys3_client = initialize_bucket()
+      gems = []
+      rubys3_client.list_objects(bucket: 'gems').contents.each do |object|
+        gems << object.key
+      end
+      gems
+    end
+
+    def self.get(dir, name)
+      rubys3_client = initialize_bucket()
+      path = File.join(dir, name)
+      rubys3_client.get_object(bucket: 'gems', key: name, response_target: path)
+      return path
+    end
+
+    def self.put(gem_file_path, gem_install: true, scope:)
+      rubys3_client = initialize_bucket()
+      if File.file?(gem_file_path)
+        gem_filename = File.basename(gem_file_path)
+        Logger.info "Installing gem: #{gem_filename}"
+        File.open(gem_file_path, 'rb') do |file|
+          rubys3_client.put_object(bucket: 'gems', key: gem_filename, body: file)
+        end
+        if gem_install
+          result = Cosmos::ProcessManager.instance.spawn(["ruby", "/cosmos/bin/cosmos", "geminstall", gem_filename], "gem_install", gem_filename, Time.now + 3600.0, scope: scope)
+          return result
+        end
+      else
+        message = "Gem file #{gem_file_path} does not exist!"
+        Logger.error message
+        raise message
+      end
+      return nil
+    end
+
+    def self.install(name_or_path)
+      temp_dir = Dir.mktmpdir
+      begin
+        if File.exist?(name_or_path)
+          gem_file_path = name_or_path
+        else
+          gem_file_path = get(temp_dir, name_or_path)
+        end
+        rubygems_url = get_setting('rubygems_url')
+        Gem.sources = [rubygems_url] if rubygems_url
+        Gem.done_installing_hooks.clear
+        Gem.install(gem_file_path, "> 0.pre", :build_args => ['--no-document'], :prerelease => true)
+      rescue => err
+        message = "Gem file #{gem_file_path} error installing to /gems\n#{err.formatted}"
+        Logger.error message
+      ensure
+        FileUtils.remove_entry(temp_dir) if temp_dir and File.exist?(temp_dir)
+      end
+    end
+
+    def self.destroy(name)
+      rubys3_client = initialize_bucket()
+      Logger.info "Removing gem: #{name}"
+      rubys3_client.delete_object(bucket: 'gems', key: name)
+      gem_name, version = self.extract_name_and_version(name)
+      begin
+        Gem::Uninstaller.new(gem_name, {:version => version, :force => true}).uninstall
+      rescue => err
+        message = "Gem file #{name} error uninstalling\n#{err.formatted}"
+        Logger.error message
+      end
+    end
+
+    def self.extract_name_and_version(name)
+      split_name = name.split('-')
+      gem_name = split_name[0..-2].join('-')
+      version = split_name[-1]
+      return gem_name, version
+    end
+
+    # private
+
+    def self.initialize_bucket
+      rubys3_client = Aws::S3::Client.new
+      unless @@bucket_initialized
+        begin
+          rubys3_client.head_bucket(bucket: 'gems')
+        rescue Aws::S3::Errors::NotFound
+          rubys3_client.create_bucket(bucket: 'gems')
+        end
+        @@bucket_initialized = true
+      end
+      return rubys3_client
+    end
+  end
+end

data/lib/cosmos/models/info_model.rb

@@ -0,0 +1,31 @@
+# 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/utilities/store'
+
+module Cosmos
+  class InfoModel
+
+    # @return Hash information and statistics about the redis server
+    def self.get()
+      return Store.info()
+    end
+
+  end
+end

data/lib/cosmos/models/interface_model.rb

@@ -0,0 +1,272 @@
+# 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'
+require 'cosmos/models/microservice_model'
+
+module Cosmos
+  class InterfaceModel < Model
+    INTERFACES_PRIMARY_KEY = 'cosmos_interfaces'
+    ROUTERS_PRIMARY_KEY = 'cosmos_routers'
+
+    attr_accessor :config_params
+    attr_accessor :target_names
+    attr_accessor :connect_on_startup
+    attr_accessor :auto_reconnect
+    attr_accessor :reconnect_delay
+    attr_accessor :disable_disconnect
+    attr_accessor :options
+    attr_accessor :protocols
+    attr_accessor :interfaces
+    attr_accessor :log
+    attr_accessor :log_raw
+    attr_accessor :needs_dependencies
+
+    # 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:)
+      super("#{scope}__#{_get_key}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+    # END NOTE
+
+    # Called by the PluginModel to allow this class to validate it's top-level keyword: "INTERFACE"
+    # Interface/Router specific keywords are handled by the instance method "handle_config"
+    # NOTE: See RouterModel for the router method implementation
+    def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
+      case keyword
+      when 'INTERFACE'
+        parser.verify_num_parameters(2, nil, "INTERFACE <Name> <Filename> <Specific Parameters>")
+        return self.new(name: parameters[0].upcase, config_params: parameters[1..-1], plugin: plugin, scope: scope)
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface: #{keyword} #{parameters.join(" ")}")
+      end
+    end
+
+    # Helper method to return the correct type based on class name
+    def self._get_type
+      self.name.to_s.split("Model")[0].upcase.split("::")[-1]
+    end
+
+    # Helper method to return the correct primary key based on class name
+    def self._get_key
+      type = _get_type
+      case type
+      when 'INTERFACE'
+        INTERFACES_PRIMARY_KEY
+      when 'ROUTER'
+        ROUTERS_PRIMARY_KEY
+      else
+        raise "Unknown type #{type} from class #{self.name}"
+      end
+    end
+
+    def initialize(
+      name:,
+      config_params: [],
+      target_names: [],
+      connect_on_startup: true,
+      auto_reconnect: true,
+      reconnect_delay: 5.0,
+      disable_disconnect: false,
+      options: [],
+      protocols: [],
+      log: true,
+      log_raw: false,
+      updated_at: nil,
+      plugin: nil,
+      needs_dependencies: false,
+      scope:
+    )
+      if self.class._get_type == 'INTERFACE'
+        super("#{scope}__#{INTERFACES_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      else
+        super("#{scope}__#{ROUTERS_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      end
+      @config_params = config_params
+      @target_names = target_names
+      @connect_on_startup = connect_on_startup
+      @auto_reconnect = auto_reconnect
+      @reconnect_delay = reconnect_delay
+      @disable_disconnect = disable_disconnect
+      @options = options
+      @protocols = protocols
+      @log = log
+      @log_raw = log_raw
+      @needs_dependencies = needs_dependencies
+    end
+
+    # Called by InterfaceMicroservice to instantiate the Interface defined
+    # by the model configuration. Must be called after get_model which
+    # calls from_json to instantiate the class and populate the attributes.
+    def build
+      klass = Cosmos.require_class(@config_params[0])
+      if @config_params.length > 1
+        interface_or_router = klass.new(*@config_params[1..-1])
+      else
+        interface_or_router = klass.new
+      end
+      interface_or_router.target_names = @target_names.dup
+      interface_or_router.connect_on_startup = @connect_on_startup
+      interface_or_router.auto_reconnect = @auto_reconnect
+      interface_or_router.reconnect_delay = @reconnect_delay
+      interface_or_router.disable_disconnect = @disable_disconnect
+      @options.each do |option|
+        interface_or_router.set_option(option[0], option[1..-1])
+      end
+      @protocols.each do |protocol|
+        klass = Cosmos.require_class(protocol[1])
+        interface_or_router.add_protocol(klass, protocol[2..-1], protocol[0].upcase.intern)
+      end
+      interface_or_router
+    end
+
+    def as_json
+      {
+        'name' => @name,
+        'config_params' => @config_params,
+        'target_names' => @target_names,
+        'connect_on_startup' => @connect_on_startup,
+        'auto_reconnect' => @auto_reconnect,
+        'reconnect_delay' => @reconnect_delay,
+        'disable_disconnect' => @disable_disconnect,
+        'options' => @options,
+        'protocols' => @protocols,
+        'log' => @log,
+        'log_raw' => @log_raw,
+        'plugin' => @plugin,
+        'needs_dependencies' => @needs_dependencies,
+        'updated_at' => @updated_at
+      }
+    end
+
+    # TODO: Not currently used but may be used by a XTCE or other format to COSMOS conversion
+    def as_config
+      result = "#{self.class._get_type} #{@name} #{@config_params.join(' ')}\n"
+      @target_names.each do |target_name|
+        result << "  MAP_TARGET #{target_name}\n"
+      end
+      result << "  DONT_CONNECT\n" unless @connect_on_startup
+      result << "  DONT_RECONNECT\n" unless @auto_reconnect
+      result << "  RECONNECT_DELAY #{@reconnect_delay}\n"
+      result << "  DISABLE_DISCONNECT\n" if @disable_disconnect
+      @options.each do |option|
+        result << "  OPTION #{option.join(' ')}\n"
+      end
+      @protocols.each do |protocol|
+        result << "  PROTOCOL #{protocol.join(' ')}\n"
+      end
+      result << "  DONT_LOG" unless @log
+      result << "  LOG_RAW" if @log_raw
+      result
+    end
+
+    # Handles Interface/Router specific configuration keywords
+    def handle_config(parser, keyword, parameters)
+      case keyword
+      when 'MAP_TARGET'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
+        @target_names << parameters[0].upcase
+
+      when 'DONT_CONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @connect_on_startup = false
+
+      when 'DONT_RECONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @auto_reconnect = false
+
+      when 'RECONNECT_DELAY'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
+        @reconnect_delay = Float(parameters[0])
+
+      when 'DISABLE_DISCONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @disable_disconnect = true
+
+      when 'OPTION'
+        parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+        @options << parameters.dup
+
+      when 'PROTOCOL'
+        usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+        parser.verify_num_parameters(2, nil, usage)
+        unless %w(READ WRITE READ_WRITE).include? parameters[0].upcase
+          raise parser.error("Invalid protocol type: #{parameters[0]}", usage)
+        end
+
+        @protocols << parameters.dup
+
+      when 'DONT_LOG'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @log = false
+
+      when 'LOG_RAW'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @log_raw = true
+
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface/Router: #{keyword} #{parameters.join(" ")}")
+
+      end
+
+      return nil
+    end
+
+    # Creates a MicroserviceModel to deploy the Interface/Router
+    def deploy(gem_path, variables)
+      type = self.class._get_type
+      microservice_name = "#{@scope}__#{type}__#{@name}"
+      microservice = MicroserviceModel.new(
+        name: microservice_name,
+        work_dir: '/cosmos/lib/cosmos/microservices',
+        cmd: ["ruby", "#{type.downcase}_microservice.rb", microservice_name],
+        target_names: @target_names,
+        plugin: @plugin,
+        needs_dependencies: @needs_dependencies,
+        scope: @scope
+      )
+      microservice.create
+      microservice.deploy(gem_path, variables)
+      Logger.info "Configured #{type.downcase} microservice #{microservice_name}"
+      microservice
+    end
+
+    # Looks up the deployed MicroserviceModel and destroy the microservice model
+    # should should trigger the operator to kill the microservice that in turn
+    # will destroy the InterfaceStatusModel when a stop is called.
+    def undeploy
+      model = MicroserviceModel.get_model(name: "#{@scope}__#{self.class._get_type}__#{@name}", scope: @scope)
+      model.destroy if model
+      if self.class._get_type == 'INTERFACE'
+        status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
+      else
+        status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
+      end
+      status_model.destroy if status_model
+    end
+  end
+end

data/lib/cosmos/models/interface_status_model.rb

@@ -0,0 +1,117 @@
+# 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
+  # Stores the status about an interface. This class also implements logic
+  # to handle status for a router since the functionality is identical
+  # (only difference is the Redis key used).
+  class InterfaceStatusModel < Model
+    INTERFACES_PRIMARY_KEY = 'cosmos_interface_status'
+    ROUTERS_PRIMARY_KEY = 'cosmos_router_status'
+
+    attr_accessor :state
+    attr_accessor :clients
+    attr_accessor :txsize
+    attr_accessor :rxsize
+    attr_accessor :txbytes
+    attr_accessor :rxbytes
+    attr_accessor :txcnt
+    attr_accessor :rxcnt
+
+    # 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:)
+      super("#{scope}__#{_get_key}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+    # END NOTE
+
+    # Helper method to return the correct type based on class name
+    def self._get_type
+      self.name.to_s.split("Model")[0].upcase.split("::")[-1]
+    end
+
+    # Helper method to return the correct primary key based on class name
+    def self._get_key
+      type = _get_type
+      case type
+      when 'INTERFACESTATUS'
+        INTERFACES_PRIMARY_KEY
+      when 'ROUTERSTATUS'
+        ROUTERS_PRIMARY_KEY
+      else
+        raise "Unknown type #{type} from class #{self.name}"
+      end
+    end
+
+    def initialize(
+      name:,
+      state:,
+      clients: 0,
+      txsize: 0,
+      rxsize: 0,
+      txbytes: 0,
+      rxbytes: 0,
+      txcnt: 0,
+      rxcnt: 0,
+      updated_at: nil,
+      plugin: nil,
+      scope:
+    )
+      if self.class._get_type == 'INTERFACESTATUS'
+        super("#{scope}__#{INTERFACES_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      else
+        super("#{scope}__#{ROUTERS_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      end
+      @state = state
+      @clients = clients
+      @txsize = txsize
+      @rxsize = rxsize
+      @txbytes = txbytes
+      @rxbytes = rxbytes
+      @txcnt = txcnt
+      @rxcnt = rxcnt
+    end
+
+    def as_json
+      {
+        'name' => @name,
+        'state' => @state,
+        'clients' => @clients,
+        'txsize' => @txsize,
+        'rxsize' => @rxsize,
+        'txbytes' => @txbytes,
+        'rxbytes' => @rxbytes,
+        'txcnt' => @txcnt,
+        'rxcnt' => @rxcnt,
+        'plugin' => @plugin,
+        'updated_at' => @updated_at
+      }
+    end
+  end
+end