3scale_toolbox 0.15.0 → 0.18.2

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

@@ -0,0 +1,99 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMethod
+      include CRD::BackendMethodSerializer
+
+      VALID_PARAMS = %w[friendly_name system_name description].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(backend:, attrs:)
+          method = backend.remote.create_backend_method(backend.id, backend.hits.id,
+                                                        Helper.filter_params(VALID_PARAMS, attrs))
+          if (errors = method['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend Method has not been created',
+                                                            errors)
+          end
+
+          new(id: method.fetch('id'), backend: backend, attrs: method)
+        end
+
+        # ref can be system_name or method_id
+        def find(backend:, ref:)
+          new(id: ref, backend: backend).tap(&:attrs)
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
+          find_by_system_name(backend: backend, system_name: ref)
+        end
+
+        def find_by_system_name(backend:, system_name:)
+          backend.methods.find { |m| m.system_name == system_name }
+        end
+      end
+
+      attr_reader :id, :backend, :remote
+
+      def initialize(id:, backend:, attrs: nil)
+        @id = id.to_i
+        @backend = backend
+        @remote = backend.remote
+        @attrs = process_attrs(attrs)
+      end
+
+      def attrs
+        @attrs ||= process_attrs(method_attrs)
+      end
+
+      def system_name
+        attrs['system_name']
+      end
+
+      def friendly_name
+        attrs['friendly_name']
+      end
+
+      def description
+        attrs['description']
+      end
+
+      def update(m_attrs)
+        new_attrs = remote.update_backend_method(backend.id, hits_id, id,
+                                                 Helper.filter_params(VALID_PARAMS, m_attrs))
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend Method has not been updated',
+                                                          errors)
+        end
+
+        # update current attrs
+        @attrs = process_attrs(new_attrs)
+      end
+
+      def delete
+        remote.delete_backend_method backend.id, hits_id, id
+      end
+
+      private
+
+      def hits_id
+        backend.hits.id
+      end
+
+      def process_attrs(metric_attrs)
+        return if metric_attrs.nil?
+
+        # system_name: my_metric_02.45498 -> system_name: my_metric_02
+        metric_attrs.merge('system_name' => metric_attrs.fetch('system_name', '').partition('.').first)
+      end
+
+      def method_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        method = remote.backend_method backend.id, hits_id, id
+        if (errors = method['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend method not read', errors)
+        end
+
+        method
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMetric
+      include CRD::BackendMetricSerializer
+
+      VALID_PARAMS = %w[friendly_name system_name unit description].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(backend:, attrs:)
+          metric = backend.remote.create_backend_metric(backend.id,
+                                                        Helper.filter_params(VALID_PARAMS, attrs))
+          if (errors = metric['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend metric has not been created',
+                                                            errors)
+          end
+
+          new(id: metric.fetch('id'), backend: backend, attrs: metric)
+        end
+
+        # ref can be system_name or metric_id
+        def find(backend:, ref:)
+          new(id: ref, backend: backend).tap(&:attrs)
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
+          find_by_system_name(backend: backend, system_name: ref)
+        end
+
+        def find_by_system_name(backend:, system_name:)
+          backend.metrics.find { |m| m.system_name == system_name }
+        end
+      end
+
+      attr_reader :id, :backend, :remote
+
+      def initialize(id:, backend:, attrs: nil)
+        @id = id.to_i
+        @backend = backend
+        @remote = backend.remote
+        @attrs = process_attrs(attrs)
+      end
+
+      def attrs
+        @attrs ||= process_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 update(m_attrs)
+        new_attrs = remote.update_backend_metric(backend.id, id,
+                                                 Helper.filter_params(VALID_PARAMS, m_attrs))
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend metric has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = process_attrs(new_attrs)
+      end
+
+      def delete
+        remote.delete_backend_metric backend.id, id
+      end
+
+      private
+
+      def process_attrs(metric_attrs)
+        return if metric_attrs.nil?
+
+        # system_name: my_metric_02.45498 -> system_name: my_metric_02
+        metric_attrs.merge('system_name' => metric_attrs.fetch('system_name', '').partition('.').first)
+      end
+
+      def metric_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        metric = remote.backend_metric backend.id, id
+        if (errors = metric['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend metric not read', errors)
+        end
+
+        metric
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module ThreeScaleToolbox
+  module Entities
+    ##
+    # BackendUsage represents Product - Backend mapping entry
+    class BackendUsage
+      include CRD::BackendUsageSerializer
+
+      CREATE_PARAMS = %w[path backend_api_id].freeze
+      public_constant :CREATE_PARAMS
+      UPDATE_PARAMS = %w[path].freeze
+      public_constant :UPDATE_PARAMS
+
+      class << self
+        def create(product:, attrs:)
+          resp = product.remote.create_backend_usage(
+            product.id,
+            Helper.filter_params(CREATE_PARAMS, attrs)
+          )
+          if (errors = resp['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend usage has not been created',
+                                                            errors)
+          end
+
+          new(id: resp.fetch('id'), product: product, attrs: resp)
+        end
+
+        def find_by_path(product:, path:)
+          resp = product.remote.list_backend_usages product.id
+          if resp.respond_to?(:has_key?) && (errors = resp['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend usage list error', errors)
+          end
+
+          backend_usage_attrs = resp.find { |bus| bus['path'] == path }
+          return if backend_usage_attrs.nil?
+
+          new(id: backend_usage_attrs.fetch('id'), product: product, attrs: backend_usage_attrs)
+        end
+      end
+
+      attr_reader :id, :product, :remote
+
+      def initialize(id:, product:, attrs: nil)
+        @id = id.to_i
+        @product = product
+        @remote = product.remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= fetch_attrs
+      end
+
+      def path
+        attrs['path']
+      end
+
+      def backend_id
+        # 3scale API returns 'backend_id'
+        # 3scale API only accepts 'backend_api_id' as params on create endpoint
+        # good job
+        attrs['backend_id']
+      end
+
+      def update(usage_attrs)
+        new_attrs = remote.update_backend_usage(
+          product.id, id,
+          Helper.filter_params(UPDATE_PARAMS, usage_attrs)
+        )
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend usage not been updated', errors)
+        end
+
+        if new_attrs['service_id'] != product.id
+          raise ThreeScaleToolbox::Error, 'Backend usage product updated'
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_backend_usage product.id, id
+      end
+
+      def backend
+        Backend.new(id: backend_id, remote: remote)
+      end
+
+      private
+
+      def fetch_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        resp = remote.backend_usage product.id, id
+        if (errors = resp['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Product backend usage not read', errors)
+        end
+
+        resp
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module ThreeScaleToolbox
+  module Entities
+    class Limit
+      include CRD::Limit
+
+      class << self
+        def create(plan:, metric_id:, attrs:)
+          resp_attrs = plan.remote.create_application_plan_limit plan.id, metric_id, attrs
+          if (errors = resp_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit 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 period
+        attrs['period']
+      end
+
+      def value
+        attrs['value']
+      end
+
+      def links
+        attrs['links'] || []
+      end
+
+      def metric_link
+        links.find { |link| link['rel'] == 'metric' }
+      end
+
+      def update(new_limit_attrs)
+        new_attrs = remote.update_application_plan_limit(plan.id, metric_id, id, new_limit_attrs)
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_application_plan_limit plan.id, metric_id, id
+      end
+
+      private
+
+      # Used by CRD::Limit
+      # 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/mapping_rule.rb

@@ -0,0 +1,90 @@
+module ThreeScaleToolbox
+  module Entities
+    class MappingRule
+      include CRD::MappingRuleSerializer
+
+      VALID_PARAMS = %w[metric_id pattern http_method delta position last].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(service:, attrs:)
+          mapping_rule = service.remote.create_mapping_rule(
+            service.id,
+            Helper.filter_params(VALID_PARAMS, attrs)
+          )
+          if (errors = mapping_rule['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('mapping rule has not been created',
+                                                            errors)
+          end
+
+          new(id: mapping_rule.fetch('id'), service: service, attrs: mapping_rule)
+        end
+      end
+
+      attr_reader :id, :service, :remote
+
+      def initialize(id:, service:, attrs: nil)
+        @id = id.to_i
+        @service = service
+        @remote = service.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 update(mr_attrs)
+        new_attrs = remote.update_mapping_rule(
+          service.id, id,
+          Helper.filter_params(VALID_PARAMS, mr_attrs)
+        )
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service mapping rule has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_mapping_rule service.id, id
+      end
+
+      private
+
+      def mapping_rule_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        mapping_rule = remote.show_mapping_rule service.id, id
+        if (errors = mapping_rule['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service mapping rule not read', errors)
+        end
+
+        mapping_rule
+      end
+    end
+  end
+end