3scale_toolbox 0.5.1 → 0.6.0

data/lib/3scale_toolbox/configuration.rb

@@ -0,0 +1,35 @@
+require 'yaml/store'
+
+module ThreeScaleToolbox
+  class Configuration
+    attr_reader :config_file
+
+    def initialize(config_file)
+      @config_file = config_file
+      @store = YAML::Store.new(config_file)
+    end
+
+    def data(key)
+      read[key]
+    end
+
+    def update(key)
+      return if key.nil?
+
+      @store.transaction do
+        @store[key] = yield @store[key]
+      end
+    end
+
+    private
+
+    # returns copy of data stored
+    def read
+      @store.transaction(true) do
+        @store.roots.each_with_object({}) do |key, obj|
+          obj[key] = @store[key]
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/entities.rb

@@ -0,0 +1 @@
+require '3scale_toolbox/entities/service'

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

@@ -0,0 +1,113 @@
+module ThreeScaleToolbox
+  module Entities
+    class Service
+      VALID_PARAMS = %w[
+        name backend_version deployment_option description
+        system_name end_user_registration_required
+        support_email tech_support_email admin_support_email
+      ].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(remote:, service:, system_name:)
+          svc_obj = remote.create_service copy_service_params(service, system_name)
+          unless svc_obj['errors'].nil?
+            raise ThreeScaleToolbox::Error, 'Service has not been saved. ' \
+              "Errors: #{svc_obj['errors']}"
+          end
+
+          new(id: svc_obj.fetch('id'), remote: remote)
+        end
+
+        private
+
+        def copy_service_params(original, system_name)
+          service_params = Helper.filter_params(VALID_PARAMS, original)
+          service_params.tap do |hash|
+            hash['system_name'] = system_name if system_name
+          end
+        end
+      end
+
+      attr_reader :id, :remote
+
+      def initialize(id:, remote:)
+        @id = id
+        @remote = remote
+      end
+
+      def show_service
+        remote.show_service id
+      end
+
+      def update_proxy(proxy)
+        remote.update_proxy id, proxy
+      end
+
+      def show_proxy
+        remote.show_proxy id
+      end
+
+      def metrics
+        remote.list_metrics id
+      end
+
+      def hits
+        hits_metric = metrics.find do |metric|
+          metric['system_name'] == 'hits'
+        end
+        raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
+
+        hits_metric
+      end
+
+      def methods
+        remote.list_methods id, hits['id']
+      end
+
+      def create_metric(metric)
+        remote.create_metric id, metric
+      end
+
+      def create_method(parent_metric_id, method)
+        remote.create_method id, parent_metric_id, method
+      end
+
+      def plans
+        remote.list_service_application_plans id
+      end
+
+      def create_application_plan(plan)
+        remote.create_application_plan id, plan
+      end
+
+      def plan_limits(plan_id)
+        remote.list_application_plan_limits(plan_id)
+      end
+
+      def create_application_plan_limit(plan_id, metric_id, limit)
+        remote.create_application_plan_limit plan_id, metric_id, limit
+      end
+
+      def mapping_rules
+        remote.list_mapping_rules id
+      end
+
+      def delete_mapping_rule(rule_id)
+        remote.delete_mapping_rule(id, rule_id)
+      end
+
+      def create_mapping_rule(mapping_rule)
+        remote.create_mapping_rule id, mapping_rule
+      end
+
+      def update_service(params)
+        remote.update_service(id, params)
+      end
+
+      def delete_service
+        remote.delete_service id
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/error.rb

@@ -0,0 +1,8 @@
+module ThreeScaleToolbox
+  # Generic error. Superclass for all specific errors.
+  class Error < ::StandardError
+  end
+
+  class InvalidUrlError < Error
+  end
+end

data/lib/3scale_toolbox/helper.rb

@@ -0,0 +1,37 @@
+module ThreeScaleToolbox
+  module Helper
+    class << self
+      def compare_hashes(first, second, keys)
+        keys.map { |key| first.fetch(key, nil) } == keys.map { |key| second.fetch(key, nil) }
+      end
+
+      ##
+      # Compute array difference with custom comparator
+      def array_difference(ary, other_ary)
+        ary.reject do |ary_elem|
+          other_ary.find do |other_ary_elem|
+            yield(ary_elem, other_ary_elem)
+          end
+        end
+      end
+
+      ##
+      # Returns new hash object with not nil valid params
+      def filter_params(valid_params, source)
+        valid_params.each_with_object({}) do |key, target|
+          target[key] = source[key] unless source[key].nil?
+        end
+      end
+
+      def parse_uri(uri)
+        # raises error when remote_str is not string, but object or something else.
+        uri_obj = URI(uri)
+        # URI::HTTP is parent of URI::HTTPS
+        # with single check both types are checked
+        raise ThreeScaleToolbox::InvalidUrlError, "invalid url: #{uri}" unless uri_obj.kind_of?(URI::HTTP)
+
+        uri_obj
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/remotes.rb

@@ -0,0 +1,93 @@
+module ThreeScaleToolbox
+  class Remotes
+    class << self
+      def from_uri(uri_str)
+        uri = Helper.parse_uri(uri_str)
+
+        authentication = uri.user
+        uri.user = ''
+        { authentication: authentication, endpoint: uri.to_s }
+      end
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    ##
+    # Fetch remotes
+    # Perform validation
+    #
+    def all
+      rmts = (config.data :remotes) || {}
+      raise_invalid unless validate(rmts)
+      rmts
+    end
+
+    def add_uri(name, uri)
+      remote = self.class.from_uri(uri)
+      add(name, remote)
+    end
+
+    def add(key, remote)
+      update do |rmts|
+        rmts.tap { |r| r[key] = remote }
+      end
+    end
+
+    def delete(key)
+      value = nil
+      update do |rmts|
+        # block should return rmts
+        # but main method should return deleted value
+        rmts.tap do |r|
+          value = if block_given?
+                    r.delete(key, &Proc.new)
+                  else
+                    r.delete(key)
+                  end
+        end
+      end
+      value
+    end
+
+    def fetch(name)
+      all.fetch name
+    end
+
+    private
+
+    attr_reader :config
+
+    ##
+    # Update remotes
+    # Perform validation
+    #
+    def update
+      config.update(:remotes) do |rmts|
+        yield(rmts || {}).tap do |new_rmts|
+          raise_invalid unless validate(new_rmts)
+        end
+      end
+    end
+
+    def raise_not_found(remote_str)
+      raise ThreeScaleToolbox::Error, "remote '#{remote_str}' not found from config file #{config.config_file}"
+    end
+
+    def raise_invalid
+      raise ThreeScaleToolbox::Error, "invalid remote configuration from config file #{config.config_file}"
+    end
+
+    def valid?(remote)
+      remote.is_a?(Hash) && remote.key?(:endpoint) && remote.key?(:authentication)
+    end
+
+    def validate(remotes)
+      case remotes
+      when Hash then remotes.values.all?(&method(:valid?))
+      else false
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/tasks.rb

@@ -0,0 +1,10 @@
+require '3scale_toolbox/tasks/copy_task'
+require '3scale_toolbox/tasks/helper_task'
+require '3scale_toolbox/tasks/copy_service_proxy_task'
+require '3scale_toolbox/tasks/copy_metrics_task'
+require '3scale_toolbox/tasks/copy_methods_task'
+require '3scale_toolbox/tasks/copy_app_plans_task'
+require '3scale_toolbox/tasks/copy_limits_task'
+require '3scale_toolbox/tasks/destroy_mapping_rules_task'
+require '3scale_toolbox/tasks/copy_mapping_rules_task'
+require '3scale_toolbox/tasks/update_service_settings_task'

data/lib/3scale_toolbox/tasks/copy_app_plans_task.rb

@@ -0,0 +1,31 @@
+module ThreeScaleToolbox
+  module Tasks
+    class CopyApplicationPlansTask
+      include CopyTask
+
+      def call
+        source_plans = source.plans
+        target_plans = target.plans
+        missing_plans = missing_app_plans(source_plans, target_plans)
+        missing_plans.each do |plan|
+          plan.delete('links')
+          plan.delete('default') # TODO: handle default plan
+          if plan.delete('custom') # TODO: what to do with custom plans?
+            puts "skipping custom plan #{plan}"
+          else
+            target.create_application_plan(plan)
+          end
+        end
+        puts "target service missing #{missing_plans.size} application plans"
+      end
+
+      private
+
+      def missing_app_plans(source_plans, target_plans)
+        ThreeScaleToolbox::Helper.array_difference(source_plans, target_plans) do |src, target|
+          ThreeScaleToolbox::Helper.compare_hashes(src, target, ['system_name'])
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/tasks/copy_limits_task.rb

@@ -0,0 +1,36 @@
+module ThreeScaleToolbox
+  module Tasks
+    class CopyLimitsTask
+      include CopyTask
+      include Helper
+
+      def call
+        metrics_map = metrics_mapping(source.metrics, target.metrics)
+        plan_mapping = application_plan_mapping(source.plans, target.plans)
+        plan_mapping.each do |plan_id, target_plan|
+          limits = source.plan_limits(plan_id)
+          limits_target = target.plan_limits(target_plan['id'])
+          missing_limits = missing_limits(limits, limits_target)
+          missing_limits.each do |limit|
+            limit.delete('links')
+            target.create_application_plan_limit(
+              target_plan['id'],
+              metrics_map.fetch(limit.fetch('metric_id')),
+              limit
+            )
+          end
+          puts "target application plan #{target_plan['id']} is missing" \
+            " #{missing_limits.size} from the original plan #{plan_id}"
+        end
+      end
+
+      private
+
+      def missing_limits(source_limits, target_limits)
+        ThreeScaleToolbox::Helper.array_difference(source_limits, target_limits) do |limit, target|
+          ThreeScaleToolbox::Helper.compare_hashes(limit, target, ['period'])
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/tasks/copy_mapping_rules_task.rb

@@ -0,0 +1,29 @@
+module ThreeScaleToolbox
+  module Tasks
+    class CopyMappingRulesTask
+      include CopyTask
+      include Helper
+
+      def call
+        metrics_map = metrics_mapping(source.metrics, target.metrics)
+        missing_rules = missing_mapping_rules(source.mapping_rules,
+                                              target.mapping_rules, metrics_map)
+        missing_rules.each do |mapping_rule|
+          mapping_rule.delete('links')
+          mapping_rule['metric_id'] = metrics_map.fetch(mapping_rule.delete('metric_id'))
+          target.create_mapping_rule mapping_rule
+        end
+        puts "created #{missing_rules.size} mapping rules"
+      end
+
+      private
+
+      def missing_mapping_rules(source_rules, target_rules, metrics_map)
+        ThreeScaleToolbox::Helper.array_difference(source_rules, target_rules) do |source_rule, target_rule|
+          ThreeScaleToolbox::Helper.compare_hashes(source_rule, target_rule, %w[pattern http_method delta]) &&
+            metrics_map.fetch(source_rule.fetch('metric_id')) == target_rule.fetch('metric_id')
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/tasks/copy_methods_task.rb

@@ -0,0 +1,29 @@
+module ThreeScaleToolbox
+  module Tasks
+    class CopyMethodsTask
+      include CopyTask
+
+      def call
+        source_methods = source.methods
+        target_methods = target.methods
+        target_hits_metric_id = target.hits['id']
+        puts "original service hits metric #{source.hits['id']} has #{source_methods.size} methods"
+        puts "target service hits metric #{target_hits_metric_id} has #{target_methods.size} methods"
+        missing = missing_methods(source_methods, target_methods).each do |method|
+          filtered_method = ThreeScaleToolbox::Helper.filter_params(%w[friendly_name system_name],
+                                                                    method)
+          target.create_method(target_hits_metric_id, filtered_method)
+        end
+        puts "created #{missing.size} missing methods on target service"
+      end
+
+      private
+
+      def missing_methods(source_methods, target_methods)
+        ThreeScaleToolbox::Helper.array_difference(source_methods, target_methods) do |method, target|
+          ThreeScaleToolbox::Helper.compare_hashes(method, target, ['system_name'])
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/tasks/copy_metrics_task.rb

@@ -0,0 +1,33 @@
+module ThreeScaleToolbox
+  module Tasks
+    class CopyMetricsTask
+      include CopyTask
+
+      def call
+        source_metrics = source.metrics
+        target_metrics = target.metrics
+
+        puts "original service has #{source_metrics.size} metrics"
+        puts "target service has #{target_metrics.size} metrics"
+
+        missing = missing_metrics(source_metrics, target_metrics)
+
+        missing.each do |metric|
+          metric.delete('links')
+          target.create_metric(metric)
+        end
+
+        puts "created #{missing.size} metrics on the target service"
+      end
+
+      private
+
+      def missing_metrics(source_metrics, target_metrics)
+        ThreeScaleToolbox::Helper.array_difference(source_metrics,
+                                                   target_metrics) do |source, target|
+          ThreeScaleToolbox::Helper.compare_hashes(source, target, ['system_name'])
+        end
+      end
+    end
+  end
+end