3scale_toolbox 0.15.0 → 0.18.2

data/lib/3scale_toolbox/crds/method_dump.rb

@@ -0,0 +1,12 @@
+module ThreeScaleToolbox
+  module CRD
+    module MethodSerializer
+      def to_cr
+        {
+          'friendlyName' => friendly_name,
+          'description' => description,
+        }
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/metric_dump.rb

@@ -0,0 +1,13 @@
+module ThreeScaleToolbox
+  module CRD
+    module MetricSerializer
+      def to_cr
+        {
+          'friendlyName' => friendly_name,
+          'unit' => unit,
+          'description' => description,
+        }
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/pricing_rule_dump.rb

@@ -0,0 +1,38 @@
+module ThreeScaleToolbox
+  module CRD
+    module PricingRuleSerializer
+      def to_cr
+        {
+          'from' => min,
+          'to' => max,
+          'pricePerUnit' => cost_per_unit,
+          'metricMethodRef' => metric_system_name,
+        }
+      end
+
+      def metric_system_name
+        # Find in service methods
+        # Find in service metrics
+        # Find in backend methods
+        # Find in backend metrics
+        if (method = plan.service.methods.find { |m| m.id == metric_id })
+          { 'systemName' => method.system_name }
+        elsif (metric = plan.service.metrics.find { |m| m.id == metric_id })
+          { 'systemName' => metric.system_name }
+        elsif (backend = backend_from_metric)
+          if (backend_metric = backend.metrics.find { |m| m.id == metric_id })
+            { 'systemName' => backend_metric.system_name, 'backend' => backend.system_name }
+          elsif (backend_method = backend.methods.find { |m| m.id == metric_id })
+            { 'systemName' => backend_method.system_name, 'backend' => backend.system_name }
+          else
+            raise ThreeScaleToolbox::Error, "Unexpected error. PricingRule #{id} " \
+              "referencing to metric id #{metric_id} which has not been found"
+          end
+        else
+          raise ThreeScaleToolbox::Error, "Unexpected error. PricingRule #{id} " \
+            "referencing to metric id #{metric_id} which has not been found"
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/product_deployment_parser.rb

@@ -0,0 +1,329 @@
+module ThreeScaleToolbox
+  module CRD
+    # ProductDeploymentCRDParser parses CRD Format
+    # https://github.com/3scale/3scale-operator/blob/3scale-2.10.0-CR2/doc/product-reference.md#productdeploymentspec
+    class ProductDeploymentParser
+      class ApicastHostedParser
+        attr_reader :authentication_parser
+
+        def initialize(cr)
+          @authentication_parser = AuthenticationParser.new(cr.fetch('authentication', {}))
+        end
+
+        def deployment_option
+          'hosted'
+        end
+
+        def method_missing(name, *args)
+          authentication_parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class ApicastSelfManagedParser
+        attr_reader :authentication_parser, :cr
+
+        def initialize(cr)
+          @cr = cr
+          @authentication_parser = AuthenticationParser.new(cr.fetch('authentication', {}))
+        end
+
+        def deployment_option
+          'self_managed'
+        end
+
+        def endpoint
+          cr['productionPublicBaseURL']
+        end
+
+        def sandbox_endpoint
+          cr['stagingPublicBaseURL']
+        end
+
+        def method_missing(name, *args)
+          authentication_parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class AuthenticationParser
+        attr_reader :parser
+
+        def initialize(cr)
+          @parser = if cr.has_key? 'userkey'
+                      UserKeyParser.new(cr.fetch('userkey'))
+                    elsif cr.has_key? 'appKeyAppID'
+                      AppKeyParser.new(cr.fetch('appKeyAppID'))
+                    elsif cr.has_key? 'oidc'
+                      OidcParser.new(cr.fetch('oidc'))
+                    else
+                      raise ThreeScaleToolbox::Error, "Unknown authentication option: #{cr.keys}"
+                    end
+        end
+
+
+        def method_missing(name, *args)
+          parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class AppKeyParser
+
+        attr_reader :cr, :security_parser, :gaterway_response_parser
+
+        def initialize(cr)
+          @cr = cr
+          @security_parser = SecurityParser.new(cr.fetch('security', {}))
+          @gaterway_response_parser = GatewayResponseParser.new(cr.fetch('gatewayResponse', {}))
+        end
+
+        def auth_app_id
+          cr['appID']
+        end
+
+        def auth_app_key
+          cr['appKey']
+        end
+
+        def credentials_location
+          cr['credentials']
+        end
+
+        def backend_version
+          '2'
+        end
+
+        def method_missing(name, *args)
+          res = security_parser.public_send(name, *args)
+          return res unless res.nil?
+
+          gaterway_response_parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class UserKeyParser
+        attr_reader :cr, :security_parser, :gaterway_response_parser
+
+        def initialize(cr)
+          @cr = cr
+          @security_parser = SecurityParser.new(cr.fetch('security', {}))
+          @gaterway_response_parser = GatewayResponseParser.new(cr.fetch('gatewayResponse', {}))
+        end
+
+        def backend_version
+          '1'
+        end
+
+        def auth_user_key
+          cr['authUserKey']
+        end
+
+        def credentials_location
+          cr['credentials']
+        end
+
+        def method_missing(name, *args)
+          res = security_parser.public_send(name, *args)
+          return res unless res.nil?
+
+          gaterway_response_parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class OidcParser
+        attr_reader :cr, :security_parser, :gaterway_response_parser, :authentication_flow_parser
+
+        def initialize(cr)
+          @cr = cr
+          @security_parser = SecurityParser.new(cr.fetch('security', {}))
+          @gaterway_response_parser = GatewayResponseParser.new(cr.fetch('gatewayResponse', {}))
+          @authentication_flow_parser = AuthenticationFlowParser.new(cr.fetch('authenticationFlow', {}))
+        end
+
+        def backend_version
+          'oidc'
+        end
+
+        def credentials_location
+          cr['credentials']
+        end
+
+        def oidc_issuer_endpoint
+          cr['issuerEndpoint']
+        end
+
+        def oidc_issuer_type
+          cr['issuerType']
+        end
+
+        def jwt_claim_with_client_id
+          cr['jwtClaimWithClientID']
+        end
+
+        def jwt_claim_with_client_id_type
+          cr['jwtClaimWithClientIDType']
+        end
+
+        def method_missing(name, *args)
+          res = authentication_flow_parser.public_send(name, *args)
+          return res unless res.nil?
+
+          res = security_parser.public_send(name, *args)
+          return res unless res.nil?
+
+          gaterway_response_parser.public_send(name, *args)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super
+        end
+      end
+
+      class SecurityParser
+        attr_reader :cr
+
+        def initialize(cr)
+          @cr = cr
+        end
+
+        def secret_token
+          cr['secretToken']
+        end
+
+        def hostname_rewrite
+          cr['hostHeader']
+        end
+
+        def method_missing(name, *args)
+          nil
+        end
+      end
+
+      class GatewayResponseParser
+        attr_reader :cr
+
+        def initialize(cr)
+          @cr = cr
+        end
+
+        def error_auth_failed
+          cr['errorAuthFailed']
+        end
+
+        def error_auth_missing
+          cr['errorAuthMissing']
+        end
+
+        def error_status_auth_failed
+          cr['errorStatusAuthFailed']
+        end
+
+        def error_headers_auth_failed
+          cr['errorHeadersAuthFailed']
+        end
+
+        def error_status_auth_missing
+          cr['errorStatusAuthMissing']
+        end
+
+        def error_headers_auth_missing
+          cr['errorHeadersAuthMissing']
+        end
+
+        def error_no_match
+          cr['errorNoMatch']
+        end
+
+        def error_status_no_match
+          cr['errorStatusNoMatch']
+        end
+
+        def error_headers_no_match
+          cr['errorHeadersNoMatch']
+        end
+
+        def error_limits_exceeded
+          cr['errorLimitsExceeded']
+        end
+
+        def error_status_limits_exceeded
+          cr['errorStatusLimitsExceeded']
+        end
+
+        def error_headers_limits_exceeded
+          cr['errorHeadersLimitsExceeded']
+        end
+
+        def method_missing(name, *args)
+          nil
+        end
+      end
+
+      class AuthenticationFlowParser
+        attr_reader :cr
+
+        def initialize(cr)
+          @cr = cr
+        end
+
+        def standard_flow_enabled
+          cr.fetch('standardFlowEnabled', false)
+        end
+
+        def implicit_flow_enabled
+          cr.fetch('implicitFlowEnabled', false)
+        end
+
+        def service_accounts_enabled
+          cr.fetch('serviceAccountsEnabled', false)
+        end
+
+        def direct_access_grants_enabled
+          cr.fetch('directAccessGrantsEnabled', false)
+        end
+
+        def method_missing(name, *args)
+          nil
+        end
+      end
+
+      attr_reader :deployment_parser
+
+      def initialize(cr)
+        @deployment_parser = if cr.has_key? 'apicastSelfManaged'
+                               ApicastSelfManagedParser.new(cr.fetch('apicastSelfManaged'))
+                             elsif cr.has_key? 'apicastHosted'
+                               ApicastHostedParser.new(cr.fetch('apicastHosted'))
+                             else
+                               raise ThreeScaleToolbox::Error, "Unknown deployment option: #{cr.keys}"
+                             end
+      end
+
+      def method_missing(name, *args)
+        deployment_parser.public_send(name, *args)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/product_dump.rb

@@ -0,0 +1,157 @@
+module ThreeScaleToolbox
+  module CRD
+    module ProductSerializer
+      def to_cr
+        {
+          'apiVersion' => 'capabilities.3scale.net/v1beta1',
+          'kind' => 'Product',
+          'metadata' => {
+            'annotations' => {
+              '3scale_toolbox_created_at' => Time.now.utc.iso8601,
+              '3scale_toolbox_version' => ThreeScaleToolbox::VERSION
+            },
+            'name' => cr_name
+          },
+          'spec' => {
+            'name' => name,
+            'systemName' => system_name,
+            'description' => description,
+            'mappingRules' => mapping_rules.map(&:to_cr),
+            'metrics' => metrics.each_with_object({}) do |metric, hash|
+              hash[metric.system_name] = metric.to_cr
+            end,
+            'methods' => methods.each_with_object({}) do |method, hash|
+              hash[method.system_name] = method.to_cr
+            end,
+            'policies' => policies,
+            'applicationPlans' => plans.each_with_object({}) do |app_plan, hash|
+              hash[app_plan.system_name] = app_plan.to_cr
+            end,
+            'backendUsages' => backend_usage_list.each_with_object({}) do |backend_usage, hash|
+              hash[backend_usage.backend.system_name] = backend_usage.to_cr
+            end,
+            'deployment' => deployment_to_cr
+          }
+        }
+      end
+
+      def cr_name
+        # Should be DNS1123 subdomain name
+        # TODO run validation for DNS1123
+        # https://kubernetes.io/docs/concepts/overview/working-with-objects/names/
+        "#{system_name.gsub(/[^[a-zA-Z0-9\-\.]]/, '.')}.#{Helper.random_lowercase_name}"
+      end
+
+      def deployment_to_cr
+        case deployment_option
+        when 'hosted'
+          hosted_deployment_to_cr
+        when 'self_managed'
+          self_managed_deployment_to_cr
+        else
+          raise ThreeScaleToolbox::Error, "Unknown deployment option: #{deployment_option}"
+        end
+      end
+
+      def hosted_deployment_to_cr
+        {
+          'apicastHosted' => { 'authentication' => authentication_to_cr }
+        }
+      end
+
+      def self_managed_deployment_to_cr
+        {
+          'apicastSelfManaged' => {
+            'authentication' => authentication_to_cr,
+            'stagingPublicBaseURL' => cached_proxy['sandbox_endpoint'],
+            'productionPublicBaseURL' => cached_proxy['endpoint']
+          }
+        }
+      end
+
+      def authentication_to_cr
+        case backend_version
+        when '1'
+          userkey_authentication_to_cr
+        when '2'
+          appkey_authentication_to_cr
+        when 'oidc'
+          oidc_authentication_to_cr
+        else
+          raise ThreeScaleToolbox::Error, "Unknown backend_version: #{backend_version}"
+        end
+      end
+
+      def userkey_authentication_to_cr
+        {
+          'userkey' => {
+            'authUserKey' => cached_proxy['auth_user_key'],
+            'credentials' => cached_proxy['credentials_location'],
+            'security' => security_to_cr,
+            'gatewayResponse' => gateway_response_to_cr
+          }
+        }
+      end
+
+      def appkey_authentication_to_cr
+        {
+          'appKeyAppID' => {
+            'appID' => cached_proxy['auth_app_id'],
+            'appKey' => cached_proxy['auth_app_key'],
+            'credentials' => cached_proxy['credentials_location'],
+            'security' => security_to_cr,
+            'gatewayResponse' => gateway_response_to_cr
+          }
+        }
+      end
+
+      def oidc_authentication_to_cr
+        {
+          'oidc' => {
+            'issuerType' => cached_proxy['oidc_issuer_type'],
+            'issuerEndpoint' => cached_proxy['oidc_issuer_endpoint'],
+            'jwtClaimWithClientID' => cached_proxy['jwt_claim_with_client_id'],
+            'jwtClaimWithClientIDType' => cached_proxy['jwt_claim_with_client_id_type'],
+            'authenticationFlow' => oidc_flow_to_cr,
+            'credentials' => cached_proxy['credentials_location'],
+            'security' => security_to_cr,
+            'gatewayResponse' => gateway_response_to_cr
+          }
+        }
+      end
+
+      def oidc_flow_to_cr
+        {
+          'standardFlowEnabled' => cached_oidc['standard_flow_enabled'],
+          'implicitFlowEnabled' => cached_oidc['implicit_flow_enabled'],
+          'serviceAccountsEnabled' => cached_oidc['service_accounts_enabled'],
+          'directAccessGrantsEnabled' => cached_oidc['direct_access_grants_enabled']
+        }
+      end
+
+      def security_to_cr
+        {
+          'hostHeader' => cached_proxy['hostname_rewrite'],
+          'secretToken' => cached_proxy['secret_token']
+        }
+      end
+
+      def gateway_response_to_cr
+        {
+          'errorStatusAuthFailed' => cached_proxy['error_status_auth_failed'],
+          'errorHeadersAuthFailed' => cached_proxy['error_headers_auth_failed'],
+          'errorAuthFailed' => cached_proxy['error_auth_failed'],
+          'errorStatusAuthMissing' => cached_proxy['error_status_auth_missing'],
+          'errorHeadersAuthMissing' => cached_proxy['error_headers_auth_missing'],
+          'errorAuthMissing' => cached_proxy['error_auth_missing'],
+          'errorStatusNoMatch' => cached_proxy['error_status_no_match'],
+          'errorHeadersNoMatch' => cached_proxy['error_headers_no_match'],
+          'errorNoMatch' => cached_proxy['error_no_match'],
+          'errorStatusLimitsExceeded' => cached_proxy['error_status_limits_exceeded'],
+          'errorHeadersLimitsExceeded' => cached_proxy['error_headers_limits_exceeded'],
+          'errorLimitsExceeded' => cached_proxy['error_limits_exceeded']
+        }
+      end
+    end
+  end
+end