apisonator 2.100.0

data/lib/3scale/backend/usage.rb

@@ -0,0 +1,63 @@
+module ThreeScale
+  module Backend
+    class Usage
+      class << self
+        def application_usage(application, timestamp)
+          usage(application, timestamp) do |metric_id, instance_period|
+            Stats::Keys.application_usage_value_key(
+                application.service_id, application.id, metric_id, instance_period)
+          end
+        end
+
+        def is_set?(usage_str)
+          usage_str && usage_str[0] == '#'.freeze
+        end
+
+        def get_from(usage_str, current_value = 0)
+          if is_set? usage_str
+            usage_str[1..-1].to_i
+          else
+            # Note: this relies on the fact that NilClass#to_i returns 0
+            # and String#to_i returns 0 on non-numeric contents.
+            current_value + usage_str.to_i
+          end
+        end
+
+        private
+
+        def usage(obj, timestamp)
+          # The timestamp does not change, so we can generate all the
+          # instantiated periods just once.
+          # This is important. Without this, the code can generate many instance
+          # periods and it ends up consuming a significant part of the total CPU
+          # time.
+          instance_periods = Period::instance_periods_for_ts(timestamp)
+
+          pairs = metric_period_pairs obj.usage_limits
+          return {} if pairs.empty?
+
+          keys = pairs.map do |(metric_id, period)|
+            yield metric_id, instance_periods[period]
+          end
+
+          values = {}
+          pairs.zip(storage.mget(keys)) do |(metric_id, period), value|
+            values[period] ||= {}
+            values[period][metric_id] = value.to_i
+          end
+          values
+        end
+
+        def metric_period_pairs(usage_limits)
+          usage_limits.map do |usage_limit|
+            [usage_limit.metric_id, usage_limit.period]
+          end
+        end
+
+        def storage
+          Storage.instance
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/usage_limit.rb

@@ -0,0 +1,115 @@
+module ThreeScale
+  module Backend
+    class UsageLimit
+      include Storable
+
+      PERIODS = (Period::ALL_DESC - [Period::Second]).freeze
+
+      attr_accessor :service_id, :plan_id, :metric_id, :period, :value
+
+      def metric_name
+        Metric.load_name(service_id, metric_id)
+      end
+
+      # NOTE: validate can ONLY be called with the guarantee that usage_data
+      # will have a matching period key.
+      def validate(usage_data)
+        usage_data[period][metric_id].to_i <= value
+      end
+
+      class << self
+        include Memoizer::Decorator
+
+        def load_all(service_id, plan_id)
+          metric_ids = Metric.load_all_ids(service_id)
+          return metric_ids if metric_ids.empty?
+
+          results = []
+          with_pairs_and_values service_id, plan_id, metric_ids do |pair, value|
+            value and results << new(service_id: service_id,
+                                     plan_id: plan_id,
+                                     metric_id: pair[0],
+                                     period: pair[1],
+                                     value: value.to_i)
+          end
+          results
+        end
+        memoize :load_all
+
+        def load_value(service_id, plan_id, metric_id, period)
+          raw_value = storage.get(key(service_id, plan_id, metric_id, period))
+          raw_value and raw_value.to_i
+        end
+
+        def save(attributes)
+          service_id = attributes[:service_id]
+          plan_id = attributes[:plan_id]
+          prefix = key_prefix(service_id, plan_id, attributes[:metric_id])
+          storage.pipelined do
+            PERIODS.each do |period|
+              p_val = attributes[period.to_sym]
+              p_val and storage.set(key_for_period(prefix, period), p_val)
+            end
+          end
+          clear_cache(service_id, plan_id)
+        end
+
+        def delete(service_id, plan_id, metric_id, period)
+          storage.del(key(service_id, plan_id, metric_id, period))
+          clear_cache(service_id, plan_id)
+        end
+
+        private
+
+        def key(service_id, plan_id, metric_id, period)
+          key_for_period(key_prefix(service_id, plan_id, metric_id), period)
+        end
+
+        # NOTE: metric_id == nil is an accepted value
+        def key_prefix(service_id, plan_id, metric_id = :none)
+          "usage_limit/service_id:#{service_id}/plan_id:#{plan_id}/metric_id:" \
+            "#{"#{metric_id}/" if metric_id != :none}"
+        end
+
+        # receives a key prefix and a pair [metric_id, period]
+        def key_for_pair(key_pre, pair)
+          encode_key("#{key_pre}#{pair[0]}/#{pair[1]}")
+        end
+
+        def key_for_period(key_pre, period)
+          encode_key(key_pre + period.to_s)
+        end
+
+        # yields [pair(metric_id, period), value]
+        def with_pairs_and_values(service_id, plan_id, metric_ids, &blk)
+          pairs, values = get_pairs_and_values_for service_id, plan_id, metric_ids
+          pairs.zip values, &blk
+        end
+
+        def get_pairs_and_values_for(service_id, plan_id, metric_ids)
+          pairs, keys = generate_pairs_and_keys_for service_id, plan_id, metric_ids
+
+          [pairs, storage.mget(keys)]
+        end
+
+        def generate_pairs_and_keys_for(service_id, plan_id, metric_ids)
+          pairs = []
+          keys = []
+
+          prefix = key_prefix service_id, plan_id
+          metric_ids.product PERIODS do |pair|
+            pairs << pair
+            keys << key_for_pair(prefix, pair)
+          end
+
+          [pairs, keys]
+        end
+
+        def clear_cache(service_id, plan_id)
+          Memoizer.clear(Memoizer.build_key(self, :load_all, service_id, plan_id))
+        end
+      end
+
+    end
+  end
+end

data/lib/3scale/backend/use_cases/provider_key_change_use_case.rb

@@ -0,0 +1,60 @@
+module ThreeScale
+  module Backend
+    class ProviderKeyChangeUseCase
+
+      def initialize(old_key, new_key)
+        @old_key = old_key
+        @new_key = new_key
+
+        validate_input
+      end
+
+      def process
+        default_service_id = Service.default_id(@old_key)
+
+        # Change the provider key on all the services and
+        # add all the services to the new provider
+        service_ids.each do |service_id|
+          storage.set Service.storage_key(service_id, :provider_key), @new_key
+          storage.sadd Service.storage_key_by_provider(@new_key, :ids), service_id
+        end
+
+        # Set the default service id to the new provider
+        storage.set Service.storage_key_by_provider(@new_key, :id), default_service_id
+
+        # Remove the old provider key and services associated to it
+        storage.del Service.storage_key_by_provider(@old_key, :id)
+        storage.del Service.storage_key_by_provider(@old_key, :ids)
+
+        clear_cache service_ids
+      end
+
+      private
+
+      def service_ids
+        @service_ids ||= Service.list(@old_key)
+      end
+
+      def validate_input
+        raise InvalidProviderKeys if [@old_key, @new_key].
+          any?{ |key| key.nil? || key.empty? } || @old_key == @new_key
+
+        raise ProviderKeyExists, @new_key if Service.list(@new_key).size != 0
+
+        raise ProviderKeyNotFound, @old_key if service_ids.size == 0
+      end
+
+      def storage
+        Service.storage
+      end
+
+      def clear_cache(service_ids)
+        service_ids.each do |service_id|
+          Service.clear_cache(@old_key, service_id)
+          Service.clear_cache(@new_key, service_id)
+        end
+      end
+
+    end
+  end
+end

data/lib/3scale/backend/util.rb

@@ -0,0 +1,17 @@
+require 'pathname'
+require 'etc'
+
+module ThreeScale
+  module Backend
+    module Util
+      def self.number_of_cpus
+        Etc.nprocessors
+      end
+
+      def self.root_dir
+        File.expand_path(File.join(Array.new(4, '..'.freeze)),
+                         Pathname.new(__FILE__).realpath)
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators.rb

@@ -0,0 +1,26 @@
+require '3scale/backend/validators/base'
+require '3scale/backend/validators/oauth_setting'
+require '3scale/backend/validators/key'
+require '3scale/backend/validators/oauth_key'
+require '3scale/backend/validators/limits'
+require '3scale/backend/validators/redirect_uri'
+require '3scale/backend/validators/referrer'
+require '3scale/backend/validators/state'
+require '3scale/backend/validators/service_state'
+
+module ThreeScale
+  module Backend
+    module Validators
+      COMMON_VALIDATORS = [Validators::Referrer,
+                           Validators::State, # application state
+                           Validators::ServiceState, # service state
+                           Validators::Limits].freeze
+
+      VALIDATORS = ([Validators::Key] + COMMON_VALIDATORS).freeze
+
+      OAUTH_VALIDATORS = ([Validators::OauthSetting,
+                           Validators::OauthKey,
+                           Validators::RedirectURI] + COMMON_VALIDATORS).freeze
+    end
+  end
+end

data/lib/3scale/backend/validators/base.rb

@@ -0,0 +1,36 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class Base
+        def self.apply(status, params)
+          new(status, params).apply
+        end
+
+        def initialize(status, params)
+          @status = status
+          @params = params
+        end
+
+        attr_reader :status
+        attr_reader :params
+
+        def service
+          @service ||= Service.load_by_id!(status.service_id)
+        end
+
+        def application
+          status.application
+        end
+
+        def succeed!
+          true
+        end
+
+        def fail!(error)
+          status.reject!(error)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators/key.rb

@@ -0,0 +1,17 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class Key < Base
+        def apply
+          if service.backend_version.to_i == 1 ||
+              application.has_no_keys? ||
+              application.has_key?(params[:app_key])
+            succeed!
+          else
+            fail!(ApplicationKeyInvalid.new(params[:app_key]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators/limits.rb

@@ -0,0 +1,57 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class Limits < Base
+
+        def apply
+          valid_limits? ? succeed! : fail!(LimitsExceeded.new)
+        end
+
+        private
+
+        def process(values, raw_usage)
+          if raw_usage
+            metrics = Metric.load_all(status.service_id)
+            usage   = metrics.process_usage(raw_usage, status.flat_usage)
+            values  = filter_metrics(values, usage.keys)
+            values  = increment_or_set(values, usage)
+          end
+
+          values
+        end
+
+        def valid_limits?
+          processed_values = process(status.values, params[:usage])
+          status.application.usage_limits.all? do |limit|
+            limit.validate(processed_values)
+          end
+        end
+
+        def filter_metrics(values, metric_ids)
+          values.inject({}) do |memo, (period, usage)|
+            memo[period] = slice_hash(usage, metric_ids)
+            memo
+          end
+        end
+
+        def increment_or_set(values, usage)
+          usage.inject(values) do |memo, (metric_id, value)|
+            memo.keys.each do |period|
+              memo[period][metric_id] = Usage.get_from value, memo[period][metric_id].to_i
+            end
+
+            memo
+          end
+        end
+
+        # TODO: Move this to extensions/hash.rb
+        def slice_hash(hash, keys)
+          keys.inject({}) do |memo, key|
+            memo[key] = hash[key] if hash.has_key?(key)
+            memo
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators/oauth_key.rb

@@ -0,0 +1,15 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class OauthKey < Base
+        def apply
+          if params[:app_key].nil? || (!params[:app_key].empty? && application.has_key?(params[:app_key]))
+            succeed!
+          else
+            fail!(ApplicationKeyInvalid.new(params[:app_key]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators/oauth_setting.rb

@@ -0,0 +1,15 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class OauthSetting < Base
+        def apply
+          if service.backend_version == 'oauth'
+            succeed!
+          else
+            fail!(OauthNotEnabled.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/validators/redirect_uri.rb

@@ -0,0 +1,33 @@
+module ThreeScale
+  module Backend
+    module Validators
+      class RedirectURI < Base
+        # This should've been named redirect_uri as per OAuth specs, but was
+        # initially named redirect_url. We check both fields, prioritizing the
+        # contents in the legacy redirect_url parameter over the "new"
+        # redirect_uri one.
+        REDIRECT_URL = 'redirect_url'.freeze
+        REDIRECT_URI = 'redirect_uri'.freeze
+
+        def apply
+          invalid_exception = RedirectURIInvalid
+          redirect_uri = if params.has_key? REDIRECT_URL
+                           invalid_exception = RedirectURLInvalid
+                           params[REDIRECT_URL]
+                         elsif params.has_key? REDIRECT_URI
+                           status.redirect_uri_field = REDIRECT_URI
+                           params[REDIRECT_URI]
+                         else
+                           nil
+                         end
+
+          if redirect_uri.nil? || redirect_uri.empty? || application.redirect_url == redirect_uri
+            succeed!
+          else
+            fail!(invalid_exception.new redirect_uri)
+          end
+        end
+      end
+    end
+  end
+end