oci-logging-analytics-kubernetes-discovery 1.0.2 → 1.1.0

data/lib/util/oci_clients.rb

@@ -13,43 +13,129 @@ module Util
 
     module_function
 
-    attr_accessor :oci_clients, :ce_client, :id_client, :lb_client, :la_client, :rs_client, :vnc_client,
-                  :oci_config, :instance_principals_signer, :auth_type, :endpoint, :auth_config_object
+    attr_accessor :oci_clients, :ce_client, :id_client, :lb_client, :la_client, :rs_client,
+                  :vcn_client, :oci_config, :instance_principals_signer, :la_endpoint,
+                  :auth_type, :auth_config_object, :oci_domain, :oci_retry_config, :oci_region
 
-    def create_clients(auth_object, options)
+    # This must be the first method called before any other method
+    def initialize(auth_config_hash)
       begin
-        @la_client = initialize_la_client(auth_object, nil)
+        initialize_auth_config(auth_config_hash)
+      rescue StandardError => e
+        logger.error("Error occurred in creating authentication object - #{e}")
+        raise e
+      end
+      logger.debug('Successfully loaded the OCI auth config.')
+
+      begin
+        create_clients
+      rescue StandardError => e
+        logger.error("Error occurred in creating OCI clients - #{e}")
+        raise e
+      end
+      logger.debug('OCI clients created successfully.')
+
+      set_clients
+    end
 
-        if options[:mode] == 'object'
-          set_clients
-          return
+    def initialize_auth_config(auth_config_hash)
+      @auth_type = auth_config_hash[:auth_type]
+      @oci_domain = auth_config_hash[:oci_domain]
+      @la_endpoint = auth_config_hash[:endpoint]
+
+      begin
+        if @auth_type == Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          @oci_config = OCI::Config.new
+          if @oci_domain.nil?
+            @instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new
+          else
+            federation_endpoint = "https://auth.#{@oci_domain}/v1/x509"
+            logger.info("Federation Endpoint: #{federation_endpoint}")
+            @instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new(
+              federation_endpoint: federation_endpoint
+            )
+          end
+          @oci_region = @instance_principals_signer.region
+        # elsif @auth_type == Enum::AuthTypeEnum::OKE_WORKLOAD_IDENTITY
+        #   @workload_identity_signer = OCI::Auth::Signers::oke_workload_resource_principal_signer
+        elsif @auth_type == Enum::AuthTypeEnum::CONFIG
+          @oci_config = OCI::ConfigFileLoader.load_config(config_file_location: auth_config_hash[:config_file_location],
+          profile_name: auth_config_hash[:profile_name])
+          @oci_region = @oci_config.region
+        else
+          raise Exception::InvalidOption, "#{@auth_type}"
         end
+      rescue StandardError => e
+        logger.error("Error occurred while initializing OCI authentication configuration. Error: #{e}")
+        raise e
+      end
+      set_auth_config_object
+    end
 
-        @ce_client = initialize_ce_client(auth_object)
-        @id_client = initialize_id_client(auth_object)
-        @lb_client = initialize_lb_client(auth_object)
-        @rs_client = initialize_rs_client(auth_object)
-        @vnc_client = initialize_vnc_client(auth_object)
+    def set_clients
+      @oci_clients = {
+        ce_client: @ce_client,
+        id_client: @id_client,
+        lb_client: @lb_client,
+        la_client: @la_client,
+        rqs_client: @rqs_client,
+        vcn_client: @vcn_client,
+        rms_client: @rms_client
+      }
+    end
+
+    def get_clients
+      @oci_clients
+    end
+
+    def get_region
+      @oci_region
+    end
+
+    def get_domain
+      @oci_domain
+    end
+
+    def create_clients()
+      begin
+        @oci_retry_config = Config::OCIClientRetryConfig.custom_retry_policy
+
+        @la_client = initialize_la_client
+        @ce_client = initialize_ce_client
+        @id_client = initialize_id_client
+        @lb_client = initialize_lb_client
+        @rqs_client = initialize_rqs_client
+        @vcn_client = initialize_vcn_client
+        @rms_client = initialize_rms_client
       rescue StandardError => e
         logger.error("Error while creating OCI clients. Error: #{e}")
         raise e
       end
-      set_clients
-      nil
+      logger.info('OCI clients created.')
     end
 
-    def initialize_ce_client(auth_object)
+    def initialize_ce_client()
       client = nil
-      logger.debug("Creating container engine client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+      unless @oci_domain.nil?
+        endpoint = "https://containerengine.#{@oci_domain}"
+        logger.info("CE Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating container engine client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: auth_object[:oci_config])
+          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::ContainerEngine::ContainerEngineClient.new(
+                config: @oci_config, endpoint: endpoint,
+                signer: @instance_principals_signer,
+                retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for container engine client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for container engine client.")
         end
+        logger.debug('CE Client created.')
         @ce_client = client
       rescue StandardError => e
         logger.error("Error while creating container engine client: #{e}")
@@ -58,20 +144,25 @@ module Util
       client
     end
 
-    def initialize_id_client(auth_object)
+    def initialize_id_client()
       client = nil
-      logger.debug("Creating identity client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+      unless @oci_domain.nil?
+        endpoint = "https://identity.#{@oci_domain}"
+        logger.info("ID Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating identity client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for identity client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for identity client.")
         end
+        logger.debug('ID Client created.')
         @id_client = client
       rescue StandardError => e
         logger.error("Error while creating identity client: #{e}")
@@ -80,20 +171,25 @@ module Util
       @id_client
     end
 
-    def initialize_lb_client(auth_object)
+    def initialize_lb_client()
       client = nil
-      logger.debug("Creating load balancer client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+      unless @oci_domain.nil?
+        endpoint = "https://iaas.#{@oci_domain}"
+        logger.info("LB Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating load balancer client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for load balancer client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for load balancer client.")
         end
+        logger.debug('LB Client created.')
         @lb_client = client
       rescue StandardError => e
         logger.error("Error while creating load balancer client: #{e}")
@@ -102,26 +198,34 @@ module Util
       @lb_client
     end
 
-    def initialize_la_client(auth_object, custom_retry_config)
+    def initialize_la_client()
       client = nil
-      logger.debug("Creating log analytics client with auth_type: #{auth_object[:auth_type]}")
-      Config::OCIClientRetryConfig.set_custom_retry_config(custom_retry_config) unless custom_retry_config.nil?
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
+      logger.debug("Creating log analytics client with auth_type: #{@auth_type}")
+
+      endpoint = @la_endpoint
+      if endpoint.nil? && !@oci_domain.nil?
+          endpoint = "https://loganalytics.#{@oci_domain}"
+          logger.info("LA Client endpoint: #{endpoint}")
+      end
 
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: auth_object[:oci_config],
-                                                             endpoint: auth_object[:endpoint],
-                                                             retry_config: Config::OCIClientRetryConfig.get_retry_config)
+          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
+                                                             endpoint: endpoint,
+                                                             retry_config: retry_config)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
-          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: auth_object[:oci_config],
-                                                             endpoint: auth_object[:endpoint],
-                                                             signer: auth_object[:instance_principals_signer],
-                                                             retry_config: Config::OCIClientRetryConfig.get_retry_config)
+          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
+                                                             endpoint: endpoint,
+                                                             signer: @instance_principals_signer,
+                                                             retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type while creating log analytics client: #{auth_object[:auth_type]}")
+          logger.warn("Unknown auth_type while creating log analytics client: #{@auth_type}")
           raise StandardError, 'Unknown auth_type for log analytics client.'
         end
+        logger.debug('LA Client created.')
         @la_client = client
       rescue StandardError => e
         logger.error("Error while creating log analytics client: #{e}")
@@ -130,86 +234,99 @@ module Util
       @la_client
     end
 
-    def initialize_rs_client(auth_object)
+    def initialize_rqs_client()
       client = nil
-      logger.debug("Creating resource search client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
+      unless @oci_domain.nil?
+        endpoint = "https://query.#{@oci_domain}"
+        logger.info("RQS Client endpoint: #{endpoint}")
+      end
+
+      logger.debug("Creating resource search client with auth_type: #{@auth_type}")
+
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for resource search client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for resource search client.")
         end
-        @rs_client = client
+        logger.debug('RQS Client created.')
+        @rqs_client = client
       rescue StandardError => e
         logger.error("Error while creating resource search client: #{e}")
         raise e
       end
-      @rs_client
+      @rqs_client
     end
 
-    def initialize_vnc_client(auth_object)
+    def initialize_vcn_client()
       client = nil
-      logger.debug("Creating virtual network client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
+      unless @oci_domain.nil?
+        # NOTE: Dec 3rd, 2024
+        # VCN endpoint does not support region.oci.domain template hence converting to region.domain template
+        endpoint = "https://iaas.#{@oci_domain.gsub('.oci', '')}"
+        logger.info("VCN Client endpoint: #{endpoint}")
+      end
+
+      logger.debug("Creating virtual network client with auth_type: #{@auth_type}")
+
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for virtual network client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for virtual network client.")
         end
-        @vnc_client = client
+        logger.debug('VCN Client created.')
+        @vcn_client = client
       rescue StandardError => e
         logger.error("Error while creating virtual network client: #{e}")
         raise e
       end
-      @vnc_client
+      @vcn_client
     end
 
-    def initialize_auth_config(auth_config_hash)
-      @endpoint = auth_config_hash[:endpoint]
+    def initialize_rms_client()
+      client = nil
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
 
-      begin
-        if !auth_config_hash[:config_file_location].nil? && !auth_config_hash[:profile_name].nil?
-          @oci_config = OCI::ConfigFileLoader.load_config(config_file_location: auth_config_hash[:config_file_location],
-                                                          profile_name: auth_config_hash[:profile_name])
-        end
+      unless @oci_domain.nil?
+        endpoint = "https://resourcemanager.#{@oci_domain}"
+        logger.info("VCN Client endpoint: #{endpoint}")
+      end
 
-        if !@oci_config.nil?
-          @auth_type = Enum::AuthTypeEnum::CONFIG
+      begin
+        case @auth_type
+        when Enum::AuthTypeEnum::CONFIG
+          client = OCI::ResourceManager::ResourceManagerClient.new(config: @oci_config,
+                                                                   endpoint: endpoint,
+                                                                   retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::ResourceManager::ResourceManagerClient.new(config: @oci_config,
+                                                                   endpoint: endpoint,
+                                                                   signer: @instance_principals_signer,
+                                                                   retry_config: retry_config)
         else
-          @oci_config = OCI::Config.new
-          @instance_principals_signer = instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new
-          @auth_type = Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for resource manager client.")
         end
+        logger.debug('RMS Client created.')
+        @rms_client = client
       rescue StandardError => e
-        logger.error("Error occurred while initializing OCI authentication configuration. Error: #{e}")
+        logger.error("Error while creating resource manager client: #{e}")
         raise e
       end
-      set_auth_config_object
-    end
-
-    def get_clients
-      @oci_clients
-    end
-
-    def set_clients
-      @oci_clients = {
-        ce_client: @ce_client,
-        id_client: @id_client,
-        lb_client: @lb_client,
-        la_client: @la_client,
-        rs_client: @rs_client,
-        vnc_client: @vnc_client
-      }
+      @rms_client
     end
 
     def get_auth_config_object
@@ -219,9 +336,11 @@ module Util
     def set_auth_config_object
       @auth_object = {
         oci_config: @oci_config,
-        endpoint: @endpoint,
+        la_endpoint: @la_endpoint,
         instance_principals_signer: @instance_principals_signer,
-        auth_type: @auth_type
+        # workload_identity_signer: @workload_identity_signer,
+        auth_type: @auth_type,
+        oci_domain: @oci_domain
       }.compact
     end
   end