3scale_toolbox 0.15.0 → 0.16.0

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

@@ -0,0 +1,76 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMappingRule
+      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 metric_id
+        @attrs['metric_id']
+      end
+
+      def metric_id=(metric_id)
+        @attrs['metric_id'] = metric_id
+      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

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

@@ -0,0 +1,90 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMethod
+      VALID_PARAMS = %w[friendly_name system_name description].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(backend:, parent_id:, attrs:)
+          method = backend.remote.create_backend_method(backend.id, parent_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'), parent_id: parent_id, backend: backend, attrs: method)
+        end
+
+        # ref can be system_name or method_id
+        def find(backend:, parent_id:, ref:)
+          new(id: ref, parent_id: parent_id, backend: backend).tap(&:attrs)
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
+          find_by_system_name(backend: backend, parent_id: parent_id, system_name: ref)
+        end
+
+        def find_by_system_name(backend:, parent_id:, system_name:)
+          backend.methods(parent_id).find { |m| m.system_name == system_name }
+        end
+      end
+
+      attr_reader :id, :parent_id, :backend, :remote
+
+      def initialize(id:, parent_id:, backend:, attrs: nil)
+        @id = id.to_i
+        @backend = backend
+        @parent_id = parent_id
+        @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 update(m_attrs)
+        new_attrs = remote.update_backend_method(backend.id, parent_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, parent_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 method_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        method = remote.backend_method backend.id, parent_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,88 @@
+module ThreeScaleToolbox
+  module Entities
+    class BackendMetric
+      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 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,99 @@
+module ThreeScaleToolbox
+  module Entities
+    ##
+    # BackendUsage represents Product - Backend mapping entry
+    class BackendUsage
+      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
+        # 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
+
+      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/service.rb

@@ -24,7 +24,7 @@ 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
 
@@ -72,7 +72,7 @@ module ThreeScaleToolbox
       end
 
       def attrs
-        @attrs ||= service_attrs
+        @attrs ||= fetch_attrs
       end
 
       def update_proxy(proxy)
@@ -249,6 +249,19 @@ 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 ==(other)
         remote.http_client.endpoint == other.remote.http_client.endpoint && id == other.id
       end
@@ -262,7 +275,9 @@ module ThreeScaleToolbox
         hits_metric
       end
 
-      def service_attrs
+      def fetch_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
         svc = remote.show_service id
         if (errors = svc['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Service attrs not read', errors)

data/lib/3scale_toolbox/error.rb

@@ -26,4 +26,7 @@ module ThreeScaleToolbox
       "#{super}. Errors: #{apierrors}"
     end
   end
+
+  class InvalidIdError < Error
+  end
 end

data/lib/3scale_toolbox/helper.rb

@@ -50,6 +50,26 @@ module ThreeScaleToolbox
       def period_already_taken_error?(error)
         Array(Hash(error)['period']).any? { |msg| msg.match(/has already been taken/) }
       end
+
+      def metrics_mapping(source_metrics, target_metrics)
+        target_metrics.map do |target|
+          source = source_metrics.find do |m|
+            compare_hashes(m, target, ['system_name'])
+          end || {}
+
+          [source['id'], target['id']]
+        end.to_h
+      end
+
+      def application_plan_mapping(source_app_plans, target_app_plans)
+        mapping = target_app_plans.map do |target|
+          source = source_app_plans.find do |app_plan|
+            compare_hashes(app_plan, target, ['system_name'])
+          end || {}
+          [source['id'], target]
+        end
+        mapping.reject { |key, _| key.nil? }
+      end
     end
 
     class BooleanTransformer

data/lib/3scale_toolbox/proxy_logger.rb

@@ -9,7 +9,7 @@ module ThreeScaleToolbox
       result = @subject.public_send(name, *args)
     ensure
       end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time
-      ::Kernel.warn "-- call #{name} args |#{args.inspect[0..200]}| response |#{result.inspect[0..200]}| - (#{end_time}s)"
+      ::Kernel.warn "-- call #{name} args |#{args.inspect[0..2000]}| response |#{result.inspect[0..2000]}| - (#{end_time}s)"
       result
     end