pisoni 1.23.1

data/lib/3scale/core/api_client/operations.rb

@@ -0,0 +1,233 @@
+module ThreeScale
+  module Core
+    module APIClient
+      module Operations
+        def self.included(base)
+          base.extend ClassMethods
+          base.prepend Initializer
+        end
+
+        private
+
+        attr_accessor :persisted
+
+        def api_save(api_options = {})
+          if persisted
+            ret = self.class.api_do_put attributes, api_options
+          else
+            ret = self.class.api_do_post attributes, api_options
+            self.persisted = ret[:ok]
+          end
+          if ret[:ok]
+            update_attributes(ret[:attributes])
+            self.dirty = false
+            true
+          else
+            false
+          end
+        end
+
+        def api_delete(api_options = {})
+          ok = self.class.api_delete attributes, api_options
+          self.persisted = false if ok
+          ok
+        end
+
+        module Initializer
+          def initialize(*args)
+            self.persisted = false
+            super
+          end
+        end
+
+        module ClassMethods
+          include ThreeScale::Core::Logger
+
+          # CRUD methods
+
+          def api_create(attributes, api_options = {}, &blk)
+            api_create_object :api_do_post, attributes, api_options, &blk
+          end
+          alias_method :api_save, :api_create
+
+          def api_read(attributes, api_options = {}, &blk)
+            api_create_object :api_do_get, attributes, api_options, &blk
+          end
+          alias_method :api_load, :api_read
+
+          def api_update(attributes, api_options = {}, &blk)
+            api_create_object :api_do_put, attributes, api_options, &blk
+          end
+
+          def api_delete(attributes, api_options = {}, &blk)
+            api_do_delete(attributes, api_options, &blk)[:ok]
+          end
+
+          # Helpers
+
+          def api_do_get(attributes, api_options = {}, &blk)
+            blk = filter_404 if blk.nil?
+            api :get, attributes, api_options, &blk
+          end
+
+          def api_do_put(attributes, api_options = {}, &blk)
+            api :put, attributes, api_options, &blk
+          end
+
+          def api_do_post(attributes, api_options = {}, &blk)
+            api :post, attributes, api_options, &blk
+          end
+
+          def api_do_delete(attributes, api_options = {}, &blk)
+            blk = filter_404 if blk.nil?
+            api :delete, attributes, api_options, &blk
+          end
+
+          def api_create_object(method, attributes, api_options = {}, &blk)
+            ret = send method, attributes, api_options.merge(build: true), &blk
+            ret[:object].send :persisted=, true if ret[:object]
+            ret[:object]
+          end
+
+          def filter_404
+            @filter_404_proc ||= proc do |result|
+              result[:response].status != 404
+            end
+          end
+          private :filter_404
+
+          def api_http(method, uri, attributes)
+            # GET, DELETE and HEAD are treated differently by Faraday. We need
+            # to set the body in there.
+            if method == :get or method == :delete
+              Core.faraday.send method, uri do |req|
+                req.body = attributes.to_json
+              end
+            else
+              Core.faraday.send method, uri, attributes.to_json
+            end
+          rescue Faraday::Error::ClientError, SystemCallError => e
+            raise ConnectionError, e
+          end
+          private :api_http
+
+          def api_parse_json(response)
+            raise JSONError, "unacceptable content-type #{response.headers['content-type']} (#{response.headers['server']}): #{response.body[0,512]}" unless response.headers['content-type'].include? 'json'
+            parse_json(response.body)
+          rescue JSON::ParserError => e
+            # you can obtain the error message with
+            # rescue JSONError => e
+            #   puts(e.cause ? e.cause.message : e.message)
+            #
+            # e.message will always return a trimmed (bounded) message, while
+            # e.cause.message, when a cause is present, may return a long
+            # message including the whole response body.
+            raise JSONError, e
+          end
+          private :api_parse_json
+
+          # Our current HTTP client (Faraday wrapper) does not expose HTTP
+          # version, which would be convenient for determining whether we have
+          # a keep-alive connection. For that we would probably need to write a
+          # Faraday middleware.
+          #
+          # Anyway, in HTTP/1.0 we are not guaranteed to have a Connection:
+          # response field, so it does not always use Connection: close (they
+          # are closed by default). HTTP/1.1 OTOH does keep-alive by default, so
+          # it will close the connection when actually sending a Connection:
+          # close. So:
+          # HTTP/1.1: KA if no Connection field or if present and not 'close'
+          # HTTP/1.0: no KA unless Connection: keep-alive.
+          # XXX UNDEFINED: no Connection header, depends on HTTP version:
+          # 1.1: keep-alive
+          # 1.0: close
+          def keep_alive_response?(response)
+            response.headers['connection'] != 'close'
+          end
+          private :keep_alive_response?
+
+          def api_response_inspect(method, uri, response, attributes, after, before)
+            "<#{keep_alive_response?(response) ? '=' : '/'}= #{response.status} #{method.upcase} #{uri} [#{attributes}] (#{after - before})"
+          end
+          private :api_response_inspect
+
+          # api method - talk with the remote HTTP service
+          #
+          # method - HTTP method to use
+          # attributes - HTTP request body parameters
+          # options:
+          #   :prefix => string/symbol - an attribute prefix, '' for none, else default_prefix
+          #   :rprefix => string/symbol - same as above, but for parsing responses
+          #   :uri => string - sets the uri for this particular request
+          #   :raise => boolean - raise APIError on error, defaults to true
+          #   :build => boolean - create a new object with response's JSON if response is ok, defaults to false
+          # block (optional) - receives two params: http status code and attributes
+          #   this block if present handles error responses, invalidates :raise option,
+          #   you should return an array of [raise (boolean), built_object (if any) or nil]
+          #
+          # returns:
+          #   a hash consisting of:
+          #     :response - http response
+          #     :response_json - http response parsed JSON
+          #     :ok - whether the response code was ok when related to the http method
+          #     :object - nil or the object created if applicable
+          #     :attributes - JSON parsed attributes of the response's body
+
+          def api(method, attributes, options = {})
+            prefix = options.fetch(:prefix, default_prefix)
+            attributes = { prefix => attributes } unless prefix.empty? or attributes.empty?
+            uri = options.fetch(:uri, default_uri)
+
+            logger.debug do
+              "==> #{method.upcase} #{uri} [#{attributes}]"
+            end
+
+            before = Time.now
+            response = api_http method, uri, attributes
+            after = Time.now
+
+            ok = status_ok? method, uri, response
+
+            response_json = begin
+              api_parse_json(response)
+            rescue JSONError => e
+              logger.error do
+                "#{api_response_inspect(method, uri, response, '', after, before)} - #{e.message}"
+              end
+              raise e
+            end
+
+            ret = { response: response, response_json: response_json, ok: ok }
+
+            logger.debug do
+              api_response_inspect(method, uri, response, response_json, after, before)
+            end
+
+            if ok
+              prefix = options.fetch(:rprefix, prefix)
+              attributes = response_json.fetch(prefix, nil) unless prefix.empty?
+
+              ret[:object] = if attributes and options[:build]
+                               new attributes
+                             else
+                               nil
+                             end
+            else
+              # something went wrong. let's either let the user fix it, and ask him to provide us
+              # with directions returned from block or just use :raise
+              do_raise = if block_given?
+                           yield(ret)
+                         else
+                           options.fetch(:raise, true)
+                         end
+              raise APIError.new(method, uri, response, response_json) if do_raise
+            end
+
+            ret[:attributes] = attributes
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/core/api_client/resource.rb

@@ -0,0 +1,52 @@
+module ThreeScale
+  module Core
+    module APIClient
+      Error = Class.new StandardError
+
+      class APIError < Error
+        attr_reader :method, :uri, :response, :attributes
+
+        def initialize(method, uri, response, attributes)
+          @method, @uri, @response, @attributes = method, uri, response, attributes
+          super "#{self.class}: #{response.status} #{method.upcase} #{uri}, attributes:" \
+            " #{attributes.inspect}, response.body: #{response.body[0,256]}"
+        end
+      end
+
+      class APIServerError < APIError
+        def initialize(method, uri, response, attributes = {})
+          super
+        end
+      end
+
+      APIInternalServerError = Class.new APIServerError
+      APIBadGatewayError = Class.new APIServerError
+      APIServiceUnavailableError = Class.new APIServerError
+
+      class ConnectionError < Error
+        def initialize(error)
+          super "#{self.class}: #{error.message}"
+        end
+      end
+
+      class JSONError < Error
+        def initialize(error)
+          msg = error.respond_to?(:message) ? error.message : error
+          super "#{self.class}: #{msg[0,512]}"
+        end
+      end
+
+      class Resource
+
+        include Attributes
+        include Support
+        include Operations
+
+        def initialize(attributes)
+          update_attributes(attributes)
+        end
+
+      end
+    end
+  end
+end

data/lib/3scale/core/api_client/support.rb

@@ -0,0 +1,55 @@
+module ThreeScale
+  module Core
+    module APIClient
+      module Support
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def status_ok?(method, uri, response)
+            status = response.status
+            # handle server errors here, since we will not be expecting JSON
+            raise internal_api_error(status).new(method, uri, response) if status >= 500
+            case method
+              when :post then [200, 201]
+              when :put then [200, 204, 202]
+              when :delete then [200, 204, 202]
+              else [200]
+            end.include? status
+          end
+
+          def parse_json(body)
+            JSON.parse(body, symbolize_names: true)
+          end
+
+          def default_uri(uri = nil)
+            return @default_uri ||= "/internal/#{self.to_s.split(':').last.downcase!}s/" unless uri
+            @default_uri = uri
+          end
+
+          def default_http_error_exception(exception = nil)
+            return @default_http_error_exception ||= APIError unless exception
+            @default_http_error_exception = exception
+          end
+
+          def default_prefix(prefix = nil)
+            return @default_prefix ||= self.to_s.split(':').last.downcase.to_sym unless prefix
+            @default_prefix = prefix
+          end
+
+          private
+
+          def internal_api_error(status)
+            case status
+              when 503 then APIServiceUnavailableError
+              when 502 then APIBadGatewayError
+              when 500 then APIInternalServerError
+              else APIServerError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/core/api_client.rb

@@ -0,0 +1,5 @@
+require '3scale/core/api_client/attributes'
+require '3scale/core/api_client/support'
+require '3scale/core/api_client/operations'
+require '3scale/core/api_client/resource'
+require '3scale/core/api_client/collection'

data/lib/3scale/core/application.rb

@@ -0,0 +1,67 @@
+module ThreeScale
+  module Core
+    class Application < APIClient::Resource
+      ## added the :user_required to distinguish between types of application:
+      ## false is the default value, do not expect user_id or ignore it if it happends
+      ## true, the user_id must be defined + the user of the service (service_id#user_id),
+      ## user_id is typically the UUID of a cellphone, or the twitter account
+      attributes :service_id, :id, :state, :plan_id, :plan_name,
+                 :redirect_url, :user_required
+
+      default_uri '/internal/services/'
+
+      def self.base_uri(service_id)
+        "#{default_uri}#{service_id}/applications/"
+      end
+      private_class_method :base_uri
+
+      def self.app_uri(service_id, id)
+        "#{base_uri(service_id)}#{id}"
+      end
+      private_class_method :app_uri
+
+      def self.key_uri(service_id, key)
+        "#{base_uri(service_id)}key/#{key}"
+      end
+      private_class_method :key_uri
+
+      def self.load(service_id, id)
+        api_read({}, uri: app_uri(service_id, id))
+      end
+
+      def self.save(attributes)
+        service_id, id = attributes.fetch(:service_id), attributes.fetch(:id)
+        api_update attributes, uri: app_uri(service_id, id)
+      end
+
+      def self.delete(service_id, id)
+        api_delete({}, uri: app_uri(service_id, id))
+      end
+
+      def save
+        api_save uri: self.class.send(:app_uri, service_id, id)
+      end
+
+      def user_required?
+        user_required
+      end
+
+      # XXX Old API. Just returns an id. DEPRECATED.
+      def self.load_id_by_key(service_id, user_key)
+        ret = api_do_get({}, uri: key_uri(service_id, user_key))
+        ret[:ok] ? ret[:attributes][:id] : nil
+      end
+
+      def self.save_id_by_key(service_id, user_key, id)
+        raise ApplicationHasInconsistentData.new(id, user_key) if (service_id.nil? || id.nil? || user_key.nil? || service_id=="" || id=="" || user_key=="")
+        ret = api_do_put({}, uri: "#{app_uri(service_id, id)}/key/#{user_key}")
+        ret[:ok]
+      end
+
+      def self.delete_id_by_key(service_id, user_key)
+        api_delete({}, uri: key_uri(service_id, user_key))
+      end
+
+    end
+  end
+end

data/lib/3scale/core/application_key.rb

@@ -0,0 +1,34 @@
+module ThreeScale
+  module Core
+    class ApplicationKey < APIClient::Resource
+      attributes :service_id, :application_id, :value
+
+      default_uri '/internal/services/'
+
+      def self.load_all(service_id, application_id)
+        results = api_do_get({}, rprefix: :application_keys, uri: application_key_uri(service_id, application_id))
+        return [] if results[:attributes].is_a?(Hash) && results[:attributes][:error]
+
+        results[:attributes].map { |attrs| new(attrs) }
+      end
+
+      def self.save(service_id, application_id, value)
+        api_save({value: value}, uri: application_key_uri(service_id, application_id), prefix: :application_key)
+      end
+
+      def self.delete(service_id, application_id, value)
+        api_delete({}, uri: application_key_uri(service_id, application_id, value))
+      end
+
+      def self.base_uri(service_id, application_id)
+        "#{default_uri}#{service_id}/applications/#{application_id}/keys/"
+      end
+      private_class_method :base_uri
+
+      def self.application_key_uri(service_id, application_id, value = nil)
+        "#{base_uri(service_id, application_id)}#{value}"
+      end
+      private_class_method :application_key_uri
+    end
+  end
+end

data/lib/3scale/core/application_referrer_filter.rb

@@ -0,0 +1,33 @@
+require 'base64'
+
+module ThreeScale
+  module Core
+    class ApplicationReferrerFilter < APIClient::Resource
+      default_uri '/internal/services/'
+
+      def self.load_all(service_id, application_id)
+        results = api_do_get({},
+                             rprefix: :referrer_filters,
+                             uri: base_uri(service_id, application_id))
+        results[:attributes]
+      end
+
+      def self.save(service_id, application_id, value)
+        result = api_do_post({ referrer_filter: value },
+                             uri: base_uri(service_id, application_id),
+                             prefix: '')
+        result[:response_json][:referrer_filter]
+      end
+
+      def self.delete(service_id, application_id, value)
+        encoded_value = Base64.urlsafe_encode64(value)
+        api_delete({}, uri: base_uri(service_id, application_id) + "/#{encoded_value}")
+      end
+
+      def self.base_uri(service_id, application_id)
+        "#{default_uri}#{service_id}/applications/#{application_id}/referrer_filters"
+      end
+      private_class_method :base_uri
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module ThreeScale
+  module Core
+    class UnknownAPIEndpoint < RuntimeError; end
+
+    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
+
+      def code
+        self.class.code
+      end
+
+      def self.code
+        underscore(name[/[^:]*$/])
+      end
+
+      # TODO: move this over to some utility module.
+      def self.underscore(string)
+        # Code stolen from ActiveSupport
+        string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+               gsub(/([a-z\d])([A-Z])/,'\1_\2').
+               downcase
+      end
+    end
+
+    NotFound = Class.new(Error)
+    Invalid  = Class.new(Error)
+
+    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 ServiceRequiresDefaultUserPlan < Error
+      def initialize
+        super %(Services without the need for registered users require a default user plan)
+      end
+    end
+
+    class ServiceIsDefaultService < Error
+      def initialize(id = nil)
+        super %(Service id="#{id}" is the default service, must be removed forcefully or make it not default before removal)
+      end
+    end
+
+    class ServiceRequiresRegisteredUser < Error
+      def initialize(id = nil)
+        super %(Service id="#{id}" requires users to be registered before hand)
+      end
+    end
+
+    class UserRequiresUsername < Error
+      def initialize
+        super %(User requires username)
+      end
+    end
+
+    class UserRequiresServiceId < Error
+      def initialize
+        super %(User requires a service id)
+      end
+    end
+
+    class UserRequiresValidServiceId < Error
+      def initialize(id)
+        super %(Service id #{id} is invalid, user requires a valid id)
+      end
+    end
+
+    class UserRequiresDefinedPlan < Error
+      def initialize(plan_id, plan_name)
+        super %(User requires a defined plan, plan id: #{plan_id} plan name: #{plan_name})
+      end
+    end
+
+    class InvalidProviderKeys < Error
+      def initialize
+        super %(Provider keys are not valid, must be not nil and different)
+      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 UsageLimitInvalidPeriods < Error
+      def initialize(periods)
+        super %(UsageLimit invalid periods #{periods})
+      end
+    end
+
+    class InvalidPerPage < Error
+      def initialize
+        super %(per_page is not valid, must be positive)
+      end
+    end
+
+    class ServiceTokenRequiresServiceId < Error
+      def initialize
+        super 'ServiceToken is invalid, service ID cannot be blank'
+      end
+    end
+
+    class ServiceTokenRequiresToken < Error
+      def initialize
+        super 'ServiceToken is invalid, token cannot be blank'
+      end
+    end
+
+    class ServiceTokenMissingParameter < Error
+      def initialize(error_text)
+        super %(ServiceToken is invalid, #{error_text})
+      end
+    end
+  end
+end

data/lib/3scale/core/event.rb

@@ -0,0 +1,26 @@
+module ThreeScale
+  module Core
+    class Event < APIClient::Resource
+      attributes :id, :type, :timestamp, :object
+
+      def self.load_all
+        results = api_do_get({}, rprefix: :events)
+        results[:attributes].map { |attrs| new attrs }
+      end
+
+      def self.delete(id)
+        api_delete({}, uri: event_uri(id))
+      end
+
+      def self.delete_upto(id)
+        results = api_do_delete({ upto_id: id }, prefix: '')
+        results[:response_json][:num_events]
+      end
+
+      def self.event_uri(id)
+        "#{default_uri}#{id}"
+      end
+      private_class_method :event_uri
+    end
+  end
+end

data/lib/3scale/core/logger.rb

@@ -0,0 +1,12 @@
+require 'injectedlogger'
+
+module ThreeScale
+  module Core
+    module Logger
+      InjectedLogger.use(:error, :info, :debug) {}
+      InjectedLogger.after_injection do |logger|
+        logger.prefix = '[core]' unless logger.prefix
+      end
+    end
+  end
+end

data/lib/3scale/core/metric.rb

@@ -0,0 +1,32 @@
+module ThreeScale
+  module Core
+    class Metric < APIClient::Resource
+      attributes :service_id, :id, :parent_id, :name
+
+      default_uri '/internal/services/'
+
+      def self.base_uri(service_id)
+        "#{default_uri}#{service_id}/metrics/"
+      end
+      private_class_method :base_uri
+
+      def self.metric_uri(service_id, id)
+        "#{base_uri(service_id)}#{id}"
+      end
+      private_class_method :metric_uri
+
+      def self.load(service_id, id)
+        api_read({}, uri: metric_uri(service_id, id))
+      end
+
+      def self.save(attributes)
+        service_id, id = attributes.fetch(:service_id), attributes.fetch(:id)
+        api_update attributes, uri: metric_uri(service_id, id)
+      end
+
+      def self.delete(service_id, id)
+        api_delete({}, uri: metric_uri(service_id, id))
+      end
+    end
+  end
+end