apisonator 2.100.0

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

@@ -0,0 +1,21 @@
+module ThreeScale
+  module Backend
+    class << self
+      def environment
+        @environment ||= ENV['RACK_ENV'] || 'development'
+      end
+
+      def production?
+        environment == 'production'
+      end
+
+      def development?
+        environment == 'development'
+      end
+
+      def test?
+        environment == 'test'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module ThreeScale
+  module Backend
+    module ErrorStorage
+      include StorageHelpers
+      extend self
+
+      PER_PAGE = 100
+      MAX_NUM_ERRORS = 1000
+
+      def store(service_id, error, context_info = {})
+        request_info = context_info[:request] || {}
+        storage.lpush(queue_key(service_id),
+                      encode(code:         error.code,
+                             message:      error.message,
+                             timestamp:    Time.now.getutc.to_s,
+                             context_info: request_info))
+        storage.ltrim(queue_key(service_id), 0, MAX_NUM_ERRORS - 1)
+      end
+
+      # Pages start at 1, same as in will_paginate.
+      def list(service_id, options = {})
+        page     = options[:page] || 1
+        per_page = options[:per_page] || PER_PAGE
+        range    = pagination_to_range(page.to_i, per_page.to_i)
+
+        raw_items = (storage.lrange(queue_key(service_id), range.begin, range.end) || [])
+        raw_items.map(&method(:decode))
+      end
+
+      def count(service_id)
+        storage.llen(queue_key(service_id))
+      end
+
+      def delete_all(service_id)
+        storage.del(queue_key(service_id))
+      end
+
+      private
+
+      def queue_key(service_id)
+        "errors/service_id:#{service_id}"
+      end
+
+      def pagination_to_range(page, per_page)
+        range_start = (page - 1) * per_page
+        range_end   = range_start + per_page - 1
+
+        range_start..range_end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,343 @@
+module ThreeScale
+  module Backend
+    class Error < RuntimeError
+      def to_xml(options = {})
+        xml = Builder::XmlMarkup.new
+        xml.instruct! unless options[:skip_instruct]
+        xml.error(message, :code => code)
+
+        xml.target!
+      end
+
+      # Note: DON'T change this to http_status; Sinatra will pick it up and break!
+      def http_code
+        403
+      end
+
+      def code
+        self.class.code
+      end
+
+      def self.code
+        underscore(name[/[^:]*$/])
+      end
+
+      def self.underscore(string)
+        string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+               gsub(/([a-z\d])([A-Z])/,'\1_\2').
+               downcase
+      end
+    end
+
+    class BadRequest < Error
+      def initialize(msg = 'request contains syntax errors, should not be repeated without modification'.freeze)
+        super msg
+      end
+
+      def http_code
+        400
+      end
+    end
+
+    class NotFound < Error
+      def http_code
+        404
+      end
+    end
+
+    class Invalid < Error
+      def http_code
+        422
+      end
+    end
+
+    class ApplicationKeyInvalid < Error
+      def initialize(key)
+        if key.blank?
+          super 'application key is missing'.freeze
+        else
+          super %(application key "#{key}" is invalid)
+        end
+      end
+    end
+
+    class ApplicationHasInconsistentData < Error
+      def initialize(id, user_key)
+        super %(Application id="#{id}" with user_key="#{user_key}" has inconsistent data and could not be saved)
+      end
+    end
+
+    class ApplicationNotFound < NotFound
+      def initialize(id = nil)
+        super %(application with id="#{id}" was not found)
+      end
+    end
+
+    class AccessTokenInvalid < NotFound
+      def initialize(id = nil)
+        super %(token "#{id}" is invalid: expired or never defined)
+      end
+    end
+
+    class AccessTokenAlreadyExists < Error
+      def initialize(id = nil)
+        super %(token "#{id}" already exists)
+      end
+    end
+
+    class AccessTokenStorageError < Error
+      def initialize(id = nil)
+        super %(storage error when saving token "#{id}")
+      end
+    end
+
+    class AccessTokenFormatInvalid < Invalid
+      def initialize
+        super 'token is either too big or has an invalid format'.freeze
+      end
+    end
+
+    class AccessTokenInvalidTTL < Invalid
+      def initialize
+        super 'the specified TTL should be a positive integer'.freeze
+      end
+    end
+
+    class ServiceNotActive < Error
+      def initialize
+        super 'service is not active'.freeze
+      end
+    end
+
+    class ApplicationNotActive < Error
+      def initialize
+        super 'application is not active'.freeze
+      end
+    end
+
+    class OauthNotEnabled < Error
+      def initialize
+        super 'oauth is not enabled'.freeze
+      end
+    end
+
+    class RedirectURIInvalid < Error
+      def initialize(uri)
+        super %(redirect_uri "#{uri}" is invalid)
+      end
+    end
+
+    class RedirectURLInvalid < Error
+      def initialize(url)
+        super %(redirect_url "#{url}" is invalid)
+      end
+    end
+
+    class LimitsExceeded < Error
+      def initialize
+        super 'usage limits are exceeded'.freeze
+      end
+    end
+
+    class ProviderKeyInvalid < Error
+      def initialize(key)
+        super %(provider key "#{key}" is invalid)
+      end
+    end
+
+    class ServiceIdInvalid < Error
+      def initialize(id)
+        super %(service id "#{id}" is invalid)
+      end
+    end
+
+    class MetricInvalid < NotFound
+      def initialize(metric_name)
+        super %(metric "#{metric_name}" is invalid)
+      end
+    end
+
+    class ReferrerFilterInvalid < Invalid
+    end
+
+    class NotValidData < Invalid
+      def initialize
+        super 'all data must be valid UTF8'.freeze
+      end
+    end
+
+    class ReferrerFiltersMissing < Error
+      def initialize
+        super 'referrer filters are missing'.freeze
+      end
+    end
+
+    class ReferrerNotAllowed < Error
+      def initialize(referrer)
+        if referrer.blank?
+          super 'referrer is missing'.freeze
+        else
+          super %(referrer "#{referrer}" is not allowed)
+        end
+      end
+    end
+
+    class RequiredParamsMissing < Invalid
+      def initialize
+        super 'missing required parameters'.freeze
+      end
+    end
+
+    class UsageValueInvalid < Error
+      def initialize(metric_name, value)
+        if !value.is_a?(String) || value.blank?
+          super %(usage value for metric "#{metric_name}" can not be empty)
+        else
+          super %(usage value "#{value}" for metric "#{metric_name}" is invalid)
+        end
+      end
+    end
+
+    class UnsupportedApiVersion < Error
+    end
+
+    class TransactionTimestampNotWithinRange < Error
+    end
+
+    class TransactionTimestampTooOld < TransactionTimestampNotWithinRange
+      def initialize(max_seconds)
+        super %(reporting transactions older than #{max_seconds} seconds is not allowed)
+      end
+    end
+
+    class TransactionTimestampTooNew < TransactionTimestampNotWithinRange
+      def initialize(max_seconds)
+        super %(reporting transactions more than #{max_seconds} seconds in the future is not allowed)
+      end
+    end
+
+    class ServiceLoadInconsistency < Error
+      def initialize(service_id, other_service_id)
+        super %(service.load_by_id with id="#{service_id}" loaded the service with id="#{other_service_id}")
+      end
+    end
+
+    class ServiceIsDefaultService < Error
+      def initialize(id = nil)
+        super %(Service id="#{id}" is the default service, cannot be removed)
+      end
+    end
+
+    class InvalidProviderKeys < Error
+      def initialize
+        super 'Provider keys are not valid, must be not nil and different'.freeze
+      end
+    end
+
+    class ProviderKeyExists < Error
+      def initialize(key)
+        super %(Provider key="#{key}" already exists)
+      end
+    end
+
+    class ProviderKeyNotFound < Error
+      def initialize(key)
+        super %(Provider key="#{key}" does not exist)
+      end
+    end
+
+    class InvalidEventType < Error
+      def initialize(type)
+        super %(Event type "#{type}" is invalid")
+      end
+    end
+
+    class ProviderKeyOrServiceTokenRequired < Error
+      def initialize
+        super 'Provider key or service token are required'.freeze
+      end
+    end
+
+    class ServiceIdMissing < Invalid
+      def initialize
+        super 'Service ID is missing'.freeze
+      end
+    end
+
+    # The name for this class stays as ServiceTokenInvalid even though the more
+    # correct name would be ServiceTokenOrIdInvalid to avoid breaking users.
+    class ServiceTokenInvalid < Error
+      def initialize(token, service_id)
+        super %(service token "#{token}" or service id "#{service_id}" is invalid)
+      end
+    end
+
+    # This is raised in these 2 situations:
+    #   1) The request does not contain a valid provider key nor a service ID.
+    #   2) The request contains a valid provider key, but does not contain a
+    #      service ID, and the provider does not have a default service
+    #      associated.
+    class ProviderKeyInvalidOrServiceMissing < Error
+      def initialize(provider_key)
+        super %(provider key "#{provider_key}" invalid and/or service ID missing)
+      end
+    end
+
+    # Legacy API support
+
+    class AuthenticationError < Error
+      def initialize
+        super 'either app_id or user_key is allowed, not both'.freeze
+      end
+    end
+
+    class UserKeyInvalid < Error
+      def initialize(key)
+        super %(user key "#{key}" is invalid)
+      end
+    end
+
+    # Bad Requests
+    class ContentTypeInvalid < BadRequest
+      def initialize(content_type)
+        super %(invalid Content-Type: #{content_type})
+      end
+    end
+
+    class TransactionsIsBlank < BadRequest
+      def initialize
+        super 'transactions parameter is blank'.freeze
+      end
+    end
+
+    class TransactionsFormatInvalid < BadRequest
+      def initialize
+        super 'transactions format is invalid'.freeze
+      end
+    end
+
+    class TransactionsHasNilTransaction < BadRequest
+      def initialize
+        super 'transactions has a nil transaction'.freeze
+      end
+    end
+
+    class ApplicationHasNoState < BadRequest
+      def initialize(id)
+        super %(Application with id="#{id}" has no state )
+      end
+    end
+
+    class DeleteServiceStatsValidationError < Error
+      def initialize(service_id, msg)
+        super "Delete stats job context validation error. Service: #{service_id}. Error: #{msg}"
+      end
+    end
+
+    class EndUsersNoLongerSupported < BadRequest
+      def initialize
+        super 'End-users are no longer supported, do not specify the user_id parameter'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+require 'net/http'
+
+module ThreeScale
+  module Backend
+    class EventStorage
+      PING_TTL    = 60
+      EVENT_TYPES = [:first_traffic, :first_daily_traffic, :alert]
+
+      class << self
+        include StorageHelpers
+
+        def store(type, object)
+          fail InvalidEventType, type unless EVENT_TYPES.member?(type)
+          new_id = storage.incrby(events_id_key, 1)
+          event  = { id: new_id, type: type, timestamp: Time.now.utc, object: object }
+          storage.zadd(events_queue_key, event[:id], encode(event))
+        end
+
+        def list
+          raw_events = storage.zrevrange(events_queue_key, 0, -1)
+          raw_events.map { |raw_event| decode_event(raw_event) }.reverse
+        end
+
+        def delete_range(to_id)
+          to_id = to_id.to_i
+          if to_id > 0
+            storage.zremrangebyscore(events_queue_key, 0, to_id)
+          else
+            0
+          end
+        end
+
+        def delete(id)
+          id = id.to_i
+          (id > 0) ? storage.zremrangebyscore(events_queue_key, id, id) : 0
+        end
+
+        def size
+          storage.zcard(events_queue_key)
+        end
+
+        def ping_if_not_empty
+          if events_hook && pending_ping?
+            request_to_events_hook
+            true
+          end
+        end
+
+        private
+
+        def events_queue_key
+          "events/queue".freeze
+        end
+
+        def events_ping_key
+          "events/ping".freeze
+        end
+
+        def events_id_key
+          "events/id".freeze
+        end
+
+        def request_to_events_hook
+          Net::HTTP.post_form(
+            events_hook_uri,
+            secret: events_hook_shared_secret,
+          )
+        end
+
+        def events_hook
+          hook = Backend.configuration.events_hook
+          if hook.nil? || hook.empty?
+            false
+          else
+            hook
+          end
+        end
+
+        def events_hook_shared_secret
+          Backend.configuration.events_hook_shared_secret
+        end
+
+        def events_hook_uri
+          URI(events_hook)
+        end
+
+        def expire_last_ping
+          storage.expire(events_ping_key, PING_TTL)
+        end
+
+        def pending_ping?
+          ## the queue is not empty and more than timeout has passed
+          ## since the front-end was notified
+          events_set_size, ping_key_value = storage.pipelined do
+            storage.zcard(events_queue_key)
+            storage.incr(events_ping_key)
+          end
+
+          return false unless ping_key_value.to_i == 1
+          expire_last_ping
+          events_set_size > 0
+        end
+
+        def decode_event(raw_event)
+          event = decode(raw_event)
+
+          # decode only symbolizes keys and parse timestamp for first level
+          obj = event[:object]
+          if obj
+            event[:object] = obj.symbolize_names
+            ts = event[:object][:timestamp]
+            event[:object][:timestamp] = Time.parse_to_utc(ts) if ts
+          end
+
+          event
+        end
+      end
+    end
+  end
+end