3scale_toolbox 0.15.0 → 0.18.2

data/lib/3scale_toolbox/entities.rb

@@ -2,7 +2,15 @@ require '3scale_toolbox/entities/service'
 require '3scale_toolbox/entities/application_plan'
 require '3scale_toolbox/entities/metric'
 require '3scale_toolbox/entities/method'
+require '3scale_toolbox/entities/mapping_rule'
+require '3scale_toolbox/entities/limit'
+require '3scale_toolbox/entities/pricing_rule'
 require '3scale_toolbox/entities/activedocs'
 require '3scale_toolbox/entities/account'
 require '3scale_toolbox/entities/proxy_config'
 require '3scale_toolbox/entities/application'
+require '3scale_toolbox/entities/backend'
+require '3scale_toolbox/entities/backend_method'
+require '3scale_toolbox/entities/backend_metric'
+require '3scale_toolbox/entities/backend_mapping_rule'
+require '3scale_toolbox/entities/backend_usage'

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

@@ -51,6 +51,18 @@ module ThreeScaleToolbox
         @attrs ||= activedoc_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def body
+        attrs['body']
+      end
+
+      def name
+        attrs['name']
+      end
+
       def delete
         remote.delete_activedocs id
       end

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

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class ApplicationPlan
+      include CRD::ApplicationPlanSerializer
+
       class << self
         def create(service:, plan_attrs:)
           plan = service.remote.create_application_plan service.id, create_plan_attrs(plan_attrs)
@@ -14,15 +16,12 @@ module ThreeScaleToolbox
         # ref can be system_name or service_id
         def find(service:, ref:)
           new(id: ref, service: service).tap(&:attrs)
-        rescue ThreeScale::API::HttpClient::NotFoundError
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
           find_by_system_name(service: service, system_name: ref)
         end
 
         def find_by_system_name(service:, system_name:)
-          plan = service.plans.find { |p| p['system_name'] == system_name }
-          return if plan.nil?
-
-          new(id: plan.fetch('id'), service: service, attrs: plan)
+          service.plans.find { |p| p.system_name == system_name }
         end
 
         def create_plan_attrs(source_attrs)
@@ -49,6 +48,22 @@ module ThreeScaleToolbox
         @attrs ||= read_plan_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def name
+        attrs['name']
+      end
+
+      def state
+        attrs['state']
+      end
+
+      def custom
+        attrs.fetch('custom', false)
+      end
+
       def update(plan_attrs)
         return attrs if update_plan_attrs(plan_attrs).empty?
 
@@ -78,9 +93,9 @@ module ThreeScaleToolbox
         # b) metrics having limits set with eternity period, but not zero value, must be updated
         # c) metrics not having limits set with eternity period, must be created
 
-        eternity_limits = limits.select { |limit| limit.fetch('period') == 'eternity' }
-        eternity_metric_ids = eternity_limits.map { |limit| limit.fetch('metric_id') }
-        service_metric_ids = service.metrics.map { |metric| metric.fetch('id') }
+        eternity_limits = limits.select { |limit| limit.period == 'eternity' }
+        eternity_metric_ids = eternity_limits.map { |limit| limit.metric_id }
+        service_metric_ids = service.metrics.map { |metric| metric.id }
         metric_ids_without_eternity = service_metric_ids - eternity_metric_ids
 
         # create eternity zero limit for each metric without eternity limit set
@@ -89,16 +104,14 @@ module ThreeScaleToolbox
         end
 
         # update eternity zero limit those metrics already having eternity limit set
-        not_zero_eternity_limits = eternity_limits.reject { |limit| limit.fetch('value').zero? }
+        not_zero_eternity_limits = eternity_limits.reject { |limit| limit.value.zero? }
         not_zero_eternity_limits.each do |limit|
-          update_limit(limit.fetch('metric_id'), limit.fetch('id'), zero_eternity_limit_attrs)
+          limit.update(zero_eternity_limit_attrs)
         end
       end
 
       def enable
-        eternity_zero_limits.each do |limit|
-          delete_limit(limit.fetch('metric_id'), limit.fetch('id'))
-        end
+        eternity_zero_limits.each(&:delete)
       end
 
       def limits
@@ -107,7 +120,9 @@ module ThreeScaleToolbox
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Limits per application plan not read', errors)
         end
 
-        plan_limits
+        plan_limits.map do |limit_attrs|
+          Limit.new(id: limit_attrs.fetch('id'), plan: self, metric_id: limit_attrs.fetch('metric_id'), attrs: limit_attrs)
+        end
       end
 
       def metric_limits(metric_id)
@@ -116,45 +131,47 @@ module ThreeScaleToolbox
         # Already reported. https://issues.jboss.org/browse/THREESCALE-2486
         # Meanwhile, the strategy will be to get all metrics from a given plan
         # and filter by metric_id
-        limits.select { |limit| limit['metric_id'] == metric_id }
+        limits.select { |limit| limit.metric_id == metric_id }
       end
 
       def create_limit(metric_id, limit_attrs)
-        limit = remote.create_application_plan_limit id, metric_id, limit_attrs
-        if (errors = limit['errors'])
-          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been created', errors)
-        end
-
-        limit
-      end
-
-      def update_limit(metric_id, limit_id, limit_attrs)
-        limit = remote.update_application_plan_limit id, metric_id, limit_id, limit_attrs
-        if (errors = limit['errors'])
-          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit not updated', errors)
-        end
-
-        limit
-      end
-
-      def delete_limit(metric_id, limit_id)
-        remote.delete_application_plan_limit id, metric_id, limit_id
+        Limit.create(plan: self, metric_id: metric_id, attrs: limit_attrs)
       end
 
       def create_pricing_rule(metric_id, pr_attrs)
-        remote.create_pricingrule id, metric_id, pr_attrs
+        PricingRule.create(plan: self, metric_id: metric_id, attrs: pr_attrs)
       end
 
       def pricing_rules
-        remote.list_pricingrules_per_application_plan id
+        pr_list = remote.list_pricingrules_per_application_plan id
+
+        if pr_list.respond_to?(:has_key?) && (errors = pr_list['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('pricing rules not read', errors)
+        end
+
+        pr_list.map do |pr_attrs|
+          PricingRule.new(id: pr_attrs.fetch('id'), plan: self, metric_id: pr_attrs.fetch('metric_id'), attrs: pr_attrs)
+        end
       end
 
       def features
-        remote.list_features_per_application_plan id
+        feature_list = remote.list_features_per_application_plan id
+
+        if feature_list.respond_to?(:has_key?) && (errors = feature_list['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('features not read', errors)
+        end
+
+        feature_list
       end
 
       def create_feature(feature_id)
-        remote.create_application_plan_feature id, feature_id
+        feature = remote.create_application_plan_feature id, feature_id
+
+        if (errors = feature['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('feature not created', errors)
+        end
+
+        feature
       end
 
       def delete
@@ -176,9 +193,27 @@ module ThreeScaleToolbox
         attrs.fetch('state') == 'published'
       end
 
+      def approval_required?
+        attrs.fetch('approval_required', true)
+      end
+
+      def trial_period_days
+        attrs.fetch('trial_period_days', 0)
+      end
+
+      def setup_fee
+        attrs.fetch('setup_fee', 0.0)
+      end
+
+      def cost_per_month
+        attrs.fetch('cost_per_month', 0.0)
+      end
+
       private
 
       def read_plan_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
         plan_attrs = remote.show_application_plan service.id, id
         if (errors = plan_attrs['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan not read', errors)
@@ -197,7 +232,7 @@ module ThreeScaleToolbox
       end
 
       def eternity_zero_limits
-        limits.select { |limit| zero_eternity_limit_attrs < limit }
+        limits.select { |limit| zero_eternity_limit_attrs < limit.attrs }
       end
 
       def zero_eternity_limit_attrs

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

@@ -0,0 +1,187 @@
+module ThreeScaleToolbox
+  module Entities
+    class Backend
+      include CRD::BackendSerializer
+
+      VALID_PARAMS = %w[name description system_name private_endpoint].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(remote:, attrs:)
+          b_attrs = remote.create_backend Helper.filter_params(VALID_PARAMS, attrs)
+          if (errors = b_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend has not been created', errors)
+          end
+
+          new(id: b_attrs.fetch('id'), remote: remote, attrs: b_attrs)
+        end
+
+        # ref can be system_name or backend_id
+        def find(remote:, ref:)
+          new(id: ref, remote: remote).tap(&:attrs)
+        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:)
+          attrs = list_backends(remote: remote).find do |backend|
+            backend['system_name'] == system_name
+          end
+          return if attrs.nil?
+
+          new(id: attrs.fetch('id'), remote: remote, attrs: attrs)
+        end
+
+        private
+
+        def list_backends(remote:)
+          backends_enum(remote: remote).reduce([], :concat)
+        end
+
+        def backends_enum(remote:)
+          Enumerator.new do |yielder|
+            page = 1
+            loop do
+              list = remote.list_backends(
+                page: page,
+                per_page: ThreeScale::API::MAX_BACKENDS_PER_PAGE
+              )
+
+              if list.respond_to?(:has_key?) && (errors = list['errors'])
+                raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend 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_BACKENDS_PER_PAGE
+
+              page += 1
+            end
+          end
+        end
+      end
+
+      attr_reader :id, :remote
+
+      def initialize(id:, remote:, attrs: nil)
+        @id = id.to_i
+        @remote = remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= fetch_backend_attrs
+      end
+
+      def system_name
+        attrs['system_name']
+      end
+
+      def description
+        attrs['description']
+      end
+
+      def name
+        attrs['name']
+      end
+
+      def private_endpoint
+        attrs['private_endpoint']
+      end
+
+      def metrics
+        metric_attr_list = metrics_and_methods.select { |metric_attrs| metric_attrs['parent_id'].nil? }
+
+        metric_attr_list.map do |metric_attrs|
+          BackendMetric.new(id: metric_attrs.fetch('id'), backend: self, attrs: metric_attrs)
+        end
+      end
+
+      def hits
+        metric_list = metrics_and_methods.map do |metric_attrs|
+          BackendMetric.new(id: metric_attrs.fetch('id'), backend: 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
+
+      # @api public
+      # @return [List]
+      def methods
+        method_attr_list = remote.list_backend_methods id, hits.id
+        if method_attr_list.respond_to?(:has_key?) && (errors = method_attr_list['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend methods not read', errors)
+        end
+
+        method_attr_list.map do |method_attrs|
+          BackendMethod.new(id: method_attrs.fetch('id'), backend: self, attrs: method_attrs)
+        end
+      end
+
+      def mapping_rules
+        m_r = remote.list_backend_mapping_rules id
+        if m_r.respond_to?(:has_key?) && (errors = m_r['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend mapping rules not read', errors)
+        end
+
+        m_r.map do |mr_attrs|
+          BackendMappingRule.new(id: mr_attrs.fetch('id'), backend: self, attrs: mr_attrs)
+        end
+      end
+
+      def update(b_attrs)
+        new_attrs = remote.update_backend id, Helper.filter_params(VALID_PARAMS, b_attrs)
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend not updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_backend id
+      end
+
+      # Compute matrics mapping
+      def metrics_mapping(other)
+        (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
+      end
+
+      def ==(other)
+        remote.http_client.endpoint == other.remote.http_client.endpoint && id == other.id
+      end
+
+      private
+
+      def metrics_and_methods
+        m_m = remote.list_backend_metrics id
+        if m_m.respond_to?(:has_key?) && (errors = m_m['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend metrics not read', errors)
+        end
+
+        m_m
+      end
+
+      def fetch_backend_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        backend = remote.backend id
+        if (errors = backend['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend attrs not read', errors)
+        end
+
+        backend
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMappingRule
+      include CRD::BackendMappingRuleSerializer
+
+      VALID_PARAMS = %w[metric_id pattern http_method delta position last].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(backend:, attrs:)
+          mapping_rule = backend.remote.create_backend_mapping_rule(
+            backend.id,
+            Helper.filter_params(VALID_PARAMS, attrs)
+          )
+          if (errors = mapping_rule['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend mapping rule has not been created',
+                                                            errors)
+          end
+
+          new(id: mapping_rule.fetch('id'), backend: backend, attrs: mapping_rule)
+        end
+      end
+
+      attr_reader :id, :backend, :remote
+
+      def initialize(id:, backend:, attrs: nil)
+        @id = id.to_i
+        @backend = backend
+        @remote = backend.remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= mapping_rule_attrs
+      end
+
+      def http_method
+        attrs['http_method']
+      end
+
+      def pattern
+        attrs['pattern']
+      end
+
+      def delta
+        attrs['delta']
+      end
+
+      def last
+        attrs['last']
+      end
+
+      def metric_id
+        attrs['metric_id']
+      end
+
+      def pattern
+        attrs['pattern']
+      end
+
+      def http_method
+        attrs['http_method']
+      end
+
+      def delta
+        attrs['delta']
+      end
+
+      def update(mr_attrs)
+        new_attrs = remote.update_backend_mapping_rule(
+          backend.id, id,
+          Helper.filter_params(VALID_PARAMS, mr_attrs)
+        )
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend mapping rule has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_backend_mapping_rule backend.id, id
+      end
+
+      private
+
+      def mapping_rule_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        mapping_rule = remote.backend_mapping_rule backend.id, id
+        if (errors = mapping_rule['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend mapping rule not read', errors)
+        end
+
+        mapping_rule
+      end
+    end
+  end
+end