3scale_toolbox 0.9.0 → 0.10.0

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_metrics_step.rb

@@ -33,22 +33,16 @@ module ThreeScaleToolbox
           end
 
           def create_metric(metric_attrs)
-            metric = service.create_metric(metric_attrs)
-            if (errors = metric['errors'])
-              raise ThreeScaleToolbox::Error, "Metric has not been created. #{errors}"
-            end
-
-            puts "Created metric: #{metric['system_name']}"
+            metric = ThreeScaleToolbox::Entities::Metric.create(service: service,
+                                                                attrs: metric_attrs)
+            puts "Created metric: #{metric.attrs['system_name']}"
           end
 
           def create_method(method_attrs)
-            method = service.create_method(service_hits['id'], method_attrs)
-            if (errors = method['errors'])
-              raise ThreeScaleToolbox::Error, "Method has not been created. #{errors}" \
-
-            end
-
-            puts "Created method: #{method_attrs['system_name']}"
+            method = ThreeScaleToolbox::Entities::Method.create(service: service,
+                                                                parent_id: service_hits['id'],
+                                                                attrs: method_attrs)
+            puts "Created method: #{method.attrs['system_name']}"
           end
         end
       end

data/lib/3scale_toolbox/commands/plans_command/import/step.rb

@@ -74,11 +74,11 @@ module ThreeScaleToolbox
           end
 
           def service_hits
-            context[:service_hits] ||= find_service_hits
+            context[:service_hits] ||= service.hits
           end
 
           def service_methods
-            context[:service_methods] ||= service.methods
+            context[:service_methods] ||= service.methods(service_hits['id'])
           end
 
           def invalidate_service_methods
@@ -116,12 +116,6 @@ module ThreeScaleToolbox
               raise ThreeScaleToolbox::Error, "Application plan #{plan_system_name} does not exist" if p.nil?
             end
           end
-
-          def find_service_hits
-            find_metric_by_system_name('hits').tap do |hits_metric|
-              raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
-            end
-          end
         end
       end
     end

data/lib/3scale_toolbox/commands/plans_command/show_command.rb

@@ -43,7 +43,7 @@ module ThreeScaleToolbox
           end
 
           def plan_attrs
-            @plan_attrs ||= plan.show
+            @plan_attrs ||= plan.attrs
           end
 
           def plan

data/lib/3scale_toolbox/commands/remote_command/remote_add.rb

@@ -31,7 +31,7 @@ module ThreeScaleToolbox
           # parsing url before trying to create client
           # raises Invalid URL when syntax is incorrect
           ThreeScaleToolbox::Helper.parse_uri(remote_url_str)
-          threescale_client(remote_url_str).list_services
+          threescale_client(remote_url_str).list_accounts
         rescue ThreeScale::API::HttpClient::ForbiddenError
           raise ThreeScaleToolbox::Error, 'remote not valid'
         end

data/lib/3scale_toolbox/entities.rb

@@ -1,2 +1,4 @@
 require '3scale_toolbox/entities/service'
 require '3scale_toolbox/entities/application_plan'
+require '3scale_toolbox/entities/metric'
+require '3scale_toolbox/entities/method'

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

@@ -5,15 +5,15 @@ module ThreeScaleToolbox
         def create(service:, plan_attrs:)
           plan = service.remote.create_application_plan service.id, build_plan_attrs(plan_attrs)
           if (errors = plan['errors'])
-            raise ThreeScaleToolbox::Error, "Application plan has not been saved. Errors: #{errors}"
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan has not been created', errors)
           end
 
-          new(id: plan.fetch('id'), service: service)
+          new(id: plan.fetch('id'), service: service, attrs: plan)
         end
 
         # ref can be system_name or service_id
         def find(service:, ref:)
-          new(id: ref, service: service).tap(&:show)
+          new(id: ref, service: service).tap(&:attrs)
         rescue ThreeScale::API::HttpClient::NotFoundError
           find_by_system_name(service: service, system_name: ref)
         end
@@ -22,7 +22,7 @@ module ThreeScaleToolbox
           plan = service.plans.find { |p| p['system_name'] == system_name }
           return if plan.nil?
 
-          new(id: plan.fetch('id'), service: service)
+          new(id: plan.fetch('id'), service: service, attrs: plan)
         end
 
         def build_plan_attrs(source_attrs)
@@ -30,32 +30,42 @@ module ThreeScaleToolbox
           source_attrs.clone.tap do |new_plan_attrs|
             # plans are created by default in hidden state
             # If published is required, 'state_event' attr has to be added
-            new_plan_attrs['state_event'] = 'publish' if new_plan_attrs['state'] == 'published'
-            new_plan_attrs['state_event'] = 'hide' if new_plan_attrs['state'] == 'hidden'
+            state = new_plan_attrs.delete('state')
+            new_plan_attrs['state_event'] = 'publish' if state == 'published'
+            new_plan_attrs['state_event'] = 'hide' if state == 'hidden'
           end
         end
       end
 
       attr_reader :id, :service, :remote
 
-      def initialize(id:, service:)
+      def initialize(id:, service:, attrs: nil)
         @id = id
         @service = service
         @remote = service.remote
+        @attrs = attrs
       end
 
-      def show
-        remote.show_application_plan service.id, id
+      def attrs
+        @attrs ||= read_plan_attrs
       end
 
       def update(plan_attrs)
-        remote.update_application_plan(service.id, id, self.class.build_plan_attrs(plan_attrs))
+        new_attrs = remote.update_application_plan(service.id, id,
+                                                   self.class.build_plan_attrs(plan_attrs))
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan has not been updated', errors)
+        end
+
+        @attrs = new_attrs
+
+        new_attrs
       end
 
       def make_default
         plan = remote.application_plan_as_default service.id, id
         if (errors = plan['errors'])
-          raise ThreeScaleToolbox::Error, "Application plan has not been set to default. Errors: #{errors}"
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan has not been set to default', errors)
         end
 
         plan
@@ -91,13 +101,27 @@ module ThreeScaleToolbox
       end
 
       def limits
-        remote.list_application_plan_limits id
+        plan_limits = remote.list_application_plan_limits id
+        if plan_limits.respond_to?(:has_key?) && (errors = plan_limits['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limits per application plan not read', errors)
+        end
+
+        plan_limits
+      end
+
+      def metric_limits(metric_id)
+        # remote.list_metric_limits(plan_id, metric_id) returns all limits for a given metric,
+        # without filtering by app plan
+        # 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 }
       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::Error, "Limit has not been created. Errors: #{errors}"
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been created', errors)
         end
 
         limit
@@ -106,7 +130,7 @@ module ThreeScaleToolbox
       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::Error, "Limit #{limit_id} has not been updated. Errors: #{errors}"
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit not updated', errors)
         end
 
         limit
@@ -138,6 +162,15 @@ module ThreeScaleToolbox
 
       private
 
+      def read_plan_attrs
+        plan_attrs = remote.show_application_plan service.id, id
+        if (errors = plan_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan not read', errors)
+        end
+
+        plan_attrs
+      end
+
       def eternity_zero_limits
         limits.select { |limit| zero_eternity_limit_attrs < limit }
       end

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

@@ -0,0 +1,80 @@
+module ThreeScaleToolbox
+  module Entities
+    class Method
+      class << self
+        def create(service:, parent_id:, attrs:)
+          method = service.remote.create_method service.id, parent_id, attrs
+          if (errors = method['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)
+        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)
+        rescue ThreeScale::API::HttpClient::NotFoundError
+          find_by_system_name(service: service, parent_id: parent_id, 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)
+        end
+      end
+
+      attr_reader :id, :parent_id, :service, :remote
+
+      def initialize(id:, parent_id:, service:, attrs: nil)
+        @id = id
+        @service = service
+        @parent_id = parent_id
+        @remote = service.remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= method_attrs
+      end
+
+      def disable
+        Metric.new(id: id, service: service).disable
+      end
+
+      def enable
+        Metric.new(id: id, service: service).enable
+      end
+
+      def update(m_attrs)
+        new_attrs = remote.update_method(service.id, parent_id, id, m_attrs)
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Method has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_method service.id, parent_id, id
+      end
+
+      private
+
+      def method_attrs
+        method = remote.show_method service.id, parent_id, id
+        if (errors = method['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Method not read', errors)
+        end
+
+        method
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module ThreeScaleToolbox
+  module Entities
+    class Metric
+      class << self
+        def create(service:, attrs:)
+          metric = service.remote.create_metric service.id, attrs
+          if (errors = metric['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Metric has not been created', errors)
+          end
+
+          new(id: metric.fetch('id'), service: service, attrs: metric)
+        end
+
+        # ref can be system_name or metric_id
+        def find(service:, ref:)
+          new(id: ref, service: service).tap(&:attrs)
+        rescue ThreeScale::API::HttpClient::NotFoundError
+          find_by_system_name(service: service, system_name: ref)
+        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)
+        end
+      end
+
+      attr_reader :id, :service, :remote
+
+      def initialize(id:, service:, attrs: nil)
+        @id = id
+        @service = service
+        @remote = service.remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= metric_attrs
+      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|
+          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)
+          end
+        end
+      end
+
+      def enable
+        service_plans.each do |plan|
+          limit = plan_zero_eternity_limit(plan)
+          plan.delete_limit(id, limit.fetch('id')) unless limit.nil?
+        end
+      end
+
+      def update(new_metric_attrs)
+        new_attrs = remote.update_metric(service.id, id, new_metric_attrs)
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Metric has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_metric service.id, id
+      end
+
+      private
+
+      def metric_attrs
+        metric = remote.show_metric service.id, id
+        if (errors = metric['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Metric attrs not read', errors)
+        end
+
+        metric
+      end
+
+      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 }
+      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
+      end
+
+      def zero_eternity_limit_attrs
+        { 'period' => 'eternity', 'value' => 0 }
+      end
+    end
+  end
+end

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

@@ -10,29 +10,35 @@ module ThreeScaleToolbox
 
       class << self
         def create(remote:, service:, system_name:)
-          svc_obj = create_service(
+          svc_attrs = create_service(
             remote: remote,
             service: copy_service_params(service, system_name)
           )
-          if (errors = svc_obj['errors'])
-            raise ThreeScaleToolbox::Error, "Service has not been saved. Errors: #{errors}" \
+          if (errors = svc_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Service has not been created', errors)
           end
 
-          new(id: svc_obj.fetch('id'), remote: remote)
+          new(id: svc_attrs.fetch('id'), remote: remote, attrs: svc_attrs)
         end
 
         # ref can be system_name or service_id
         def find(remote:, ref:)
-          new(id: ref, remote: remote).tap(&:show_service)
+          new(id: ref, remote: remote).tap(&:attrs)
         rescue ThreeScale::API::HttpClient::NotFoundError
           find_by_system_name(remote: remote, system_name: ref)
         end
 
         def find_by_system_name(remote:, system_name:)
-          service = remote.list_services.find { |svc| svc['system_name'] == system_name }
-          return if service.nil?
+          service_list = remote.list_services
 
-          new(id: service.fetch('id'), remote: remote)
+          if service_list.respond_to?(:has_key?) && (errors = service_list['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Service list not read', errors)
+          end
+
+          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)
         end
 
         private
@@ -62,25 +68,42 @@ module ThreeScaleToolbox
 
       attr_reader :id, :remote
 
-      def initialize(id:, remote:)
+      def initialize(id:, remote:, attrs: nil)
         @id = id
         @remote = remote
+        @attrs = attrs
       end
 
-      def show_service
-        remote.show_service id
+      def attrs
+        @attrs ||= service_attrs
       end
 
       def update_proxy(proxy)
-        remote.update_proxy id, proxy
+        new_proxy_attrs = remote.update_proxy id, proxy
+
+        if (errors = new_proxy_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service proxy not updated', errors)
+        end
+
+        new_proxy_attrs
       end
 
-      def show_proxy
-        remote.show_proxy id
+      def proxy
+        proxy_attrs = remote.show_proxy id
+        if (errors = proxy_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service proxy not read', errors)
+        end
+
+        proxy_attrs
       end
 
       def metrics
-        remote.list_metrics id
+        service_metrics = remote.list_metrics id
+        if service_metrics.respond_to?(:has_key?) && (errors = service_metrics['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service metrics not read', errors)
+        end
+
+        service_metrics
       end
 
       def hits
@@ -92,20 +115,22 @@ module ThreeScaleToolbox
         hits_metric
       end
 
-      def methods
-        remote.list_methods id, hits['id']
-      end
-
-      def create_metric(metric)
-        remote.create_metric id, metric
-      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'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service methods not read', errors)
+        end
 
-      def create_method(parent_metric_id, method)
-        remote.create_method id, parent_metric_id, method
+        service_methods
       end
 
       def plans
-        remote.list_service_application_plans id
+        service_plans = remote.list_service_application_plans id
+        if service_plans.respond_to?(:has_key?) && (errors = service_plans['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service plans not read', errors)
+        end
+
+        service_plans
       end
 
       def mapping_rules
@@ -120,11 +145,19 @@ module ThreeScaleToolbox
         remote.create_mapping_rule id, mapping_rule
       end
 
-      def update_service(params)
-        remote.update_service(id, params)
+      def update(svc_attrs)
+        new_attrs = remote.update_service id, svc_attrs
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service not updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
       end
 
-      def delete_service
+      def delete
         remote.delete_service id
       end
 
@@ -136,31 +169,72 @@ module ThreeScaleToolbox
         remote.update_policies(id, params)
       end
 
-      def list_activedocs
-        remote.list_activedocs.select do |activedoc|
+      def activedocs
+        tenant_activedocs = remote.list_activedocs
+
+        if tenant_activedocs.respond_to?(:has_key?) && (errors = tenant_activedocs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service activedocs not read', errors)
+        end
+
+        tenant_activedocs.select do |activedoc|
           # service_id is optional attr. It would return nil and would not match
           # activedocs endpoints return service_id as integers
           activedoc['service_id'] == id.to_i
         end
       end
 
-      def show_oidc
-        remote.show_oidc id
+      def oidc
+        service_oidc = remote.show_oidc id
+
+        if (errors = service_oidc['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service oicdc not read', errors)
+        end
+
+        service_oidc
       end
 
       def update_oidc(oidc_settings)
-        remote.update_oidc(id, oidc_settings)
+        new_oidc = remote.update_oidc(id, oidc_settings)
+
+        if (errors = new_oidc['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service oicdc not updated', errors)
+        end
+
+        new_oidc
       end
 
       def features
-        remote.list_service_features id
+        service_features = remote.list_service_features id
+
+        if service_features.respond_to?(:has_key?) && (errors = service_features['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service features not read', errors)
+        end
+
+        service_features
       end
 
-      def create_feature(attrs)
+      def create_feature(feature_attrs)
         # Workaround until issue is fixed: https://github.com/3scale/porta/issues/774
-        attrs['scope'] = 'ApplicationPlan' if attrs['scope'] == 'application_plan'
-        attrs['scope'] = 'ServicePlan' if attrs['scope'] == 'service_plan'
-        remote.create_service_feature id, attrs
+        feature_attrs['scope'] = 'ApplicationPlan' if feature_attrs['scope'] == 'application_plan'
+        feature_attrs['scope'] = 'ServicePlan' if feature_attrs['scope'] == 'service_plan'
+        new_feature = remote.create_service_feature id, feature_attrs
+
+        if (errors = new_feature['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service feature not created', errors)
+        end
+
+        new_feature
+      end
+
+      private
+
+      def service_attrs
+        svc = remote.show_service id
+        if (errors = svc['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service attrs not read', errors)
+        end
+
+        svc
       end
     end
   end