3scale_toolbox 0.15.0 → 0.18.2

data/lib/3scale_toolbox/entities/method.rb

@@ -1,38 +1,35 @@
 module ThreeScaleToolbox
   module Entities
     class Method
+      include CRD::MethodSerializer
+
       class << self
-        def create(service:, parent_id:, attrs:)
-          method = service.remote.create_method service.id, parent_id, attrs
-          if (errors = method['errors'])
+        def create(service:, attrs:)
+          method_attrs = service.remote.create_method service.id, service.hits.id, attrs
+          if (errors = method_attrs['errors'])
             raise ThreeScaleToolbox::ThreeScaleApiError.new('Method has not been created', errors)
-
           end
 
-          new(id: method.fetch('id'), parent_id: parent_id, service: service, attrs: method)
+          new(id: method_attrs.fetch('id'), service: service, attrs: method_attrs)
         end
 
         # ref can be system_name or method_id
-        def find(service:, parent_id:, ref:)
-          new(id: ref, parent_id: parent_id, service: service).tap(&:attrs)
+        def find(service:, ref:)
+          new(id: ref, service: service).tap(&:attrs)
         rescue ThreeScale::API::HttpClient::NotFoundError
-          find_by_system_name(service: service, parent_id: parent_id, system_name: ref)
+          find_by_system_name(service: service, system_name: ref)
         end
 
-        def find_by_system_name(service:, parent_id:, system_name:)
-          method = service.methods(parent_id).find { |m| m['system_name'] == system_name }
-          return if method.nil?
-
-          new(id: method.fetch('id'), parent_id: parent_id, service: service, attrs: method)
+        def find_by_system_name(service:, system_name:)
+          service.methods.find { |m| m.system_name == system_name }
         end
       end
 
-      attr_reader :id, :parent_id, :service, :remote
+      attr_reader :id, :service, :remote
 
-      def initialize(id:, parent_id:, service:, attrs: nil)
+      def initialize(id:, service:, attrs: nil)
         @id = id.to_i
         @service = service
-        @parent_id = parent_id
         @remote = service.remote
         @attrs = attrs
       end
@@ -41,6 +38,18 @@ module ThreeScaleToolbox
         @attrs ||= method_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def friendly_name
+        attrs['friendly_name']
+      end
+
+      def description
+        attrs['description']
+      end
+
       def disable
         Metric.new(id: id, service: service).disable
       end
@@ -50,7 +59,7 @@ module ThreeScaleToolbox
       end
 
       def update(m_attrs)
-        new_attrs = remote.update_method(service.id, parent_id, id, m_attrs)
+        new_attrs = remote.update_method(service.id, hits_id, id, m_attrs)
         if (errors = new_attrs['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Method has not been updated', errors)
         end
@@ -62,13 +71,18 @@ module ThreeScaleToolbox
       end
 
       def delete
-        remote.delete_method service.id, parent_id, id
+        remote.delete_method service.id, hits_id, id
       end
 
+
       private
 
+      def hits_id
+        service.hits.id
+      end
+
       def method_attrs
-        method = remote.show_method service.id, parent_id, id
+        method = remote.show_method service.id, hits_id, id
         if (errors = method['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Method not read', errors)
         end

data/lib/3scale_toolbox/entities/metric.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class Metric
+      include CRD::MetricSerializer
+
       class << self
         def create(service:, attrs:)
           metric = service.remote.create_metric service.id, attrs
@@ -19,10 +21,7 @@ module ThreeScaleToolbox
         end
 
         def find_by_system_name(service:, system_name:)
-          metric = service.metrics.find { |m| m['system_name'] == system_name }
-          return if metric.nil?
-
-          new(id: metric.fetch('id'), service: service, attrs: metric)
+          service.metrics.find { |m| m.system_name == system_name }
         end
       end
 
@@ -39,25 +38,41 @@ module ThreeScaleToolbox
         @attrs ||= metric_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def friendly_name
+        attrs['friendly_name']
+      end
+
+      def unit
+        attrs['unit']
+      end
+
+      def description
+        attrs['description']
+      end
+
       def disable
         # For each plan, get limits for the current metric
         # if already disabled -> NOOP
         # if non zero eternity limit exist, update
         # if non eternity limit exist, create
-        service_plans.each do |plan|
+        service.plans.each do |plan|
           eternity_limit = plan_eternity_limit(plan)
           if eternity_limit.nil?
             plan.create_limit(id, zero_eternity_limit_attrs)
-          elsif !eternity_limit.fetch('value').zero?
-            plan.update_limit(id, eternity_limit.fetch('id'), zero_eternity_limit_attrs)
+          elsif !eternity_limit.value.zero?
+            eternity_limit.update(zero_eternity_limit_attrs)
           end
         end
       end
 
       def enable
-        service_plans.each do |plan|
+        service.plans.each do |plan|
           limit = plan_zero_eternity_limit(plan)
-          plan.delete_limit(id, limit.fetch('id')) unless limit.nil?
+          limit.delete unless limit.nil?
         end
       end
 
@@ -90,19 +105,15 @@ module ThreeScaleToolbox
 
       def plan_zero_eternity_limit(plan)
         # only one limit for eternity period is allowed per (plan_id, metric_id)
-        plan.metric_limits(id).find { |limit| limit > zero_eternity_limit_attrs }
+        #plan.metric_limits(id).find { |limit| limit.attrs > zero_eternity_limit_attrs }
+        plan.metric_limits(id).find do |limit|
+          limit.attrs > zero_eternity_limit_attrs
+        end
       end
 
       def plan_eternity_limit(plan)
         # only one limit for eternity period is allowed per (plan_id, metric_id)
-        plan.metric_limits(id).find { |limit| limit['period'] == 'eternity' }
-      end
-
-      def service_plans
-        service.plans.map do |plan_attrs|
-          ThreeScaleToolbox::Entities::ApplicationPlan.new(id: plan_attrs.fetch('id'),
-                                                           service: service)
-        end
+        plan.metric_limits(id).find { |limit| limit.period == 'eternity' }
       end
 
       def zero_eternity_limit_attrs

data/lib/3scale_toolbox/entities/pricing_rule.rb

@@ -0,0 +1,63 @@
+module ThreeScaleToolbox
+  module Entities
+    class PricingRule
+      include CRD::PricingRuleSerializer
+
+      class << self
+        def create(plan:, metric_id:, attrs:)
+          resp_attrs = plan.remote.create_pricingrule plan.id, metric_id, attrs
+          if (errors = resp_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Pricing rule has not been created', errors)
+          end
+
+          new(id: resp_attrs.fetch('id'), plan: plan, metric_id: metric_id, attrs: resp_attrs)
+        end
+      end
+
+      attr_reader :id, :plan, :remote, :attrs, :metric_id
+
+      def initialize(id:, plan:, metric_id:, attrs:)
+        @id = id.to_i
+        @plan = plan
+        @remote = plan.remote
+        @metric_id = metric_id
+        @attrs = attrs
+      end
+
+      def cost_per_unit
+        attrs['cost_per_unit'].to_f
+      end
+
+      def min
+        attrs['min']
+      end
+
+      def max
+        attrs['max']
+      end
+
+      def links
+        attrs['links'] || []
+      end
+
+      def metric_link
+        links.find { |link| link['rel'] == 'metric' }
+      end
+
+      def delete
+        remote.delete_application_plan_pricingrule plan.id, metric_id, id
+      end
+
+      private
+
+      # Used by CRD::PricingRule
+      # Returns the backend hosting the metric
+      def backend_from_metric
+        backend_id = Helper.backend_metric_link_parser(metric_link['href'] || '')
+        return if backend_id.nil?
+
+        Backend.new(id: backend_id.to_i, remote: remote)
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/entities/proxy_config.rb

@@ -52,7 +52,6 @@ module ThreeScaleToolbox
         end
         proxy_cfg
       end
-
     end
   end
 end

data/lib/3scale_toolbox/entities/service.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class Service
+      include CRD::ProductSerializer
+
       VALID_PARAMS = %w[
         name backend_version deployment_option description
         system_name end_user_registration_required
@@ -24,21 +26,17 @@ module ThreeScaleToolbox
         # ref can be system_name or service_id
         def find(remote:, ref:)
           new(id: ref, remote: remote).tap(&:attrs)
-        rescue ThreeScale::API::HttpClient::NotFoundError
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
           find_by_system_name(remote: remote, system_name: ref)
         end
 
         def find_by_system_name(remote:, system_name:)
-          service_list = remote.list_services
-
-          if service_list.respond_to?(:has_key?) && (errors = service_list['errors'])
-            raise ThreeScaleToolbox::ThreeScaleApiError.new('Service list not read', errors)
+          attrs = list_services(remote: remote).find do |svc|
+            svc['system_name'] == system_name
           end
+          return if attrs.nil?
 
-          service_attrs = service_list.find { |svc| svc['system_name'] == system_name }
-          return if service_attrs.nil?
-
-          new(id: service_attrs.fetch('id'), remote: remote, attrs: service_attrs)
+          new(id: attrs.fetch('id'), remote: remote, attrs: attrs)
         end
 
         private
@@ -61,6 +59,36 @@ module ThreeScaleToolbox
         def filtered_service_params(original_params)
           Helper.filter_params(VALID_PARAMS, original_params)
         end
+
+        def list_services(remote:)
+          services_enum(remote: remote).reduce([], :concat)
+        end
+
+        def services_enum(remote:)
+          Enumerator.new do |yielder|
+            page = 1
+            loop do
+              list = remote.list_services(
+                page: page,
+                per_page: ThreeScale::API::MAX_SERVICES_PER_PAGE
+              )
+
+              if list.respond_to?(:has_key?) && (errors = list['errors'])
+                raise ThreeScaleToolbox::ThreeScaleApiError.new('Service list not read', errors)
+              end
+
+              break if list.nil?
+
+              yielder << list
+
+              # The API response does not tell how many pages there are available
+              # If one page is not fully filled, it means that it is the last page.
+              break if list.length < ThreeScale::API::MAX_SERVICES_PER_PAGE
+
+              page += 1
+            end
+          end
+        end
       end
 
       attr_reader :id, :remote
@@ -72,7 +100,27 @@ module ThreeScaleToolbox
       end
 
       def attrs
-        @attrs ||= service_attrs
+        @attrs ||= fetch_attrs
+      end
+
+      def system_name
+        attrs['system_name']
+      end
+
+      def name
+        attrs['name']
+      end
+
+      def description
+        attrs['description']
+      end
+
+      def deployment_option
+        attrs['deployment_option']
+      end
+
+      def backend_version
+        attrs['backend_version']
       end
 
       def update_proxy(proxy)
@@ -94,37 +142,42 @@ module ThreeScaleToolbox
         proxy_attrs
       end
 
+      def cached_proxy
+        @cached_proxy ||= proxy
+      end
+
+      # @api public
+      # @return [List]
       def metrics
-        # cache result to reuse
-        metric_and_method_list = metrics_and_methods
-        hits_metric_obj = hits_metric(metric_and_method_list)
-        hits_id = hits_metric_obj.fetch('id')
+        metric_attr_list = metrics_and_methods.select { |metric_attrs| metric_attrs['parent_id'].nil? }
 
-        ThreeScaleToolbox::Helper.array_difference(metric_and_method_list, methods(hits_id)) do |metric, method|
-          ThreeScaleToolbox::Helper.compare_hashes(metric, method, %w[id])
+        metric_attr_list.map do |metric_attrs|
+          Metric.new(id: metric_attrs.fetch('id'), service: self, attrs: metric_attrs)
         end
       end
 
       def hits
-        hits_metric(metrics_and_methods)
+        metric_list = metrics_and_methods.map do |metric_attrs|
+          Metric.new(id: metric_attrs.fetch('id'), service: self, attrs: metric_attrs)
+        end
+        metric_list.find { |metric| metric.system_name == 'hits' }.tap do |hits_metric|
+          raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
+        end
       end
 
-      def methods(parent_metric_id)
-        service_methods = remote.list_methods id, parent_metric_id
-        if service_methods.respond_to?(:has_key?) && (errors = service_methods['errors'])
+      # @api public
+      # @return [List]
+      def methods
+        method_attr_list = remote.list_methods id, hits.id
+        if method_attr_list.respond_to?(:has_key?) && (errors = method_attr_list['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Service methods not read', errors)
         end
 
-        service_methods
-      end
-
-      def metrics_and_methods
-        m_m = remote.list_metrics id
-        if m_m.respond_to?(:has_key?) && (errors = m_m['errors'])
-          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service metrics not read', errors)
+        method_attr_list.map do |method_attrs|
+          Method.new(id: method_attrs.fetch('id'),
+                     service: self,
+                     attrs: method_attrs)
         end
-
-        m_m
       end
 
       def plans
@@ -133,19 +186,24 @@ module ThreeScaleToolbox
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Service plans not read', errors)
         end
 
-        service_plans
+        service_plans.map do |plan_attrs|
+          ApplicationPlan.new(id: plan_attrs.fetch('id'),
+                              service: self,
+                              attrs: plan_attrs)
+        end
       end
 
       def mapping_rules
-        remote.list_mapping_rules id
-      end
-
-      def delete_mapping_rule(rule_id)
-        remote.delete_mapping_rule(id, rule_id)
-      end
+        mr_list = remote.list_mapping_rules id
+        if mr_list.respond_to?(:has_key?) && (errors = mr_list['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service mapping rules not read', errors)
+        end
 
-      def create_mapping_rule(mapping_rule)
-        remote.create_mapping_rule id, mapping_rule
+        mr_list.map do |mr_attrs|
+          MappingRule.new(id: mr_attrs.fetch('id'),
+                          service: self,
+                          attrs: mr_attrs)
+        end
       end
 
       def update(svc_attrs)
@@ -165,7 +223,12 @@ module ThreeScaleToolbox
       end
 
       def policies
-        remote.show_policies id
+        policy_chain = remote.show_policies id
+        if policy_chain.respond_to?(:has_key?) && (errors = policy_chain['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service policies not read', errors)
+        end
+
+        policy_chain
       end
 
       def update_policies(params)
@@ -179,8 +242,12 @@ module ThreeScaleToolbox
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Service activedocs not read', errors)
         end
 
-        tenant_activedocs.select do |activedoc|
-          activedoc['service_id'] == id
+        service_activedocs = tenant_activedocs.select do |activedoc_attrs|
+          activedoc_attrs['service_id'] == id
+        end
+
+        service_activedocs.map do |activedoc_attrs|
+          Entities::ActiveDocs.new(id: activedoc_attrs.fetch('id'), remote: remote, attrs: activedoc_attrs)
         end
       end
 
@@ -194,6 +261,10 @@ module ThreeScaleToolbox
         service_oidc
       end
 
+      def cached_oidc
+        @cached_oidc ||= oidc
+      end
+
       def update_oidc(oidc_settings)
         new_oidc = remote.update_oidc(id, oidc_settings)
 
@@ -249,20 +320,58 @@ module ThreeScaleToolbox
         end
       end
 
+      def backend_usage_list
+        resp = remote.list_backend_usages id
+        if resp.respond_to?(:has_key?) && (errors = resp['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Product backend usage not read', errors)
+        end
+
+        resp.map do |backend_usage_attrs|
+          Entities::BackendUsage.new(id: backend_usage_attrs.fetch('id'),
+                                     product: self,
+                                     attrs: backend_usage_attrs)
+        end
+      end
+
+      def create_mapping_rule(mr_attrs)
+        Entities::MappingRule.create(service: self, attrs: mr_attrs)
+      end
+
+      def proxy_deploy
+        proxy_attrs = remote.proxy_deploy id
+        if proxy_attrs.respond_to?(:has_key?) && (errors = proxy_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Proxy configuration not deployed', errors)
+        end
+
+        proxy_attrs
+      end
+
+      # Compute matrics mapping between products, including related backend metrics as well
+      def metrics_mapping(other)
+        mapping = (metrics + methods).product(other.metrics + other.methods).select do |m_a, m_b|
+          m_a.system_name == m_b.system_name
+        end.map { |m_a, m_b| [m_a.id, m_b.id] }.to_h
+
+        backend_pairs = backend_usage_list.map(&:backend).product(other.backend_usage_list.map(&:backend)).select do |b_a, b_b|
+          b_a.system_name == b_b.system_name
+        end
+
+        backend_pairs.each do |b_a, b_b|
+          mapping.merge!(b_a.metrics_mapping(b_b))
+        end
+
+        mapping
+      end
+
       def ==(other)
         remote.http_client.endpoint == other.remote.http_client.endpoint && id == other.id
       end
 
       private
 
-      def hits_metric(metric_list)
-        hits_metric = metric_list.find { |metric| metric['system_name'] == 'hits' }
-        raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
-
-        hits_metric
-      end
+      def fetch_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
 
-      def service_attrs
         svc = remote.show_service id
         if (errors = svc['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Service attrs not read', errors)
@@ -285,6 +394,15 @@ module ThreeScaleToolbox
 
         new_attrs
       end
+
+      def metrics_and_methods
+        m_m = remote.list_metrics id
+        if m_m.respond_to?(:has_key?) && (errors = m_m['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service metrics not read', errors)
+        end
+
+        m_m
+      end
     end
   end
 end