3scale_toolbox 0.13.0 → 0.17.1

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

@@ -1,9 +1,24 @@
 module ThreeScaleToolbox
   # Generic error. Superclass for all specific errors.
   class Error < ::StandardError
+    def code
+      'E_3SCALE'
+    end
+
+    def kind
+      self.class
+    end
+
+    def stacktrace
+      # For managed errors, stacktrace should not be necessary
+      nil
+    end
   end
 
   class InvalidUrlError < Error
+    def code
+      'E_INVALID_URL'
+    end
   end
 
   class ActiveDocsNotFoundError < Error
@@ -12,6 +27,10 @@ module ThreeScaleToolbox
     def initialize(id)
       super("ActiveDocs with ID #{id} not found")
     end
+
+    def code
+      'E_ACTIVEDOCS_NOT_FOUND'
+    end
   end
 
   class ThreeScaleApiError < Error
@@ -25,5 +44,39 @@ module ThreeScaleToolbox
     def message
       "#{super}. Errors: #{apierrors}"
     end
+
+    def code
+      'E_3SCALE_API'
+    end
+  end
+
+  class InvalidIdError < Error
+    def code
+      'E_INVALID_ID'
+    end
+  end
+
+  class UnexpectedError < ::StandardError
+    attr_reader :unexpectederror
+
+    def initialize(err)
+      @unexpectederror = err
+    end
+
+    def message
+      unexpectederror.message
+    end
+
+    def kind
+      unexpectederror.class
+    end
+
+    def code
+      'E_UNKNOWN'
+    end
+
+    def stacktrace
+      unexpectederror.backtrace
+    end
   end
 end