apisonator 2.100.0

data/apisonator.gemspec

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require '3scale/backend/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'apisonator'
+  s.version     = ThreeScale::Backend::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Ciganek", "Tiago Macedo", "Josep M. Pujol",
+                   "Toni Reina", "Wojciech Ogrodowczyk",
+                   "Alejandro Martinez Ruiz", "David Ortiz Lopez",
+                   "Eguzki Astiz Lezaun", "Miguel Soriano Domenech"]
+  s.email       = 'backend@3scale.net'
+  s.homepage    = 'http://www.3scale.net'
+  s.summary     = '3scale web service management system backend'
+  s.description = 'This gem provides a daemon that handles authorization and reporting of web services managed by 3scale.'
+  s.license     = 'Apache-2.0'
+  s.metadata    = { 'source_code_uri' => 'https://github.com/3scale/apisonator' }
+
+  s.required_ruby_version     = ">= 2.4.0"
+  s.required_rubygems_version = ">= 1.3.7"
+
+  s.files = Dir.glob('{lib,bin,app,config}/**/*')
+  s.files << 'README.md'
+  s.files << 'CHANGELOG.md'
+  s.files << 'Rakefile'
+  s.files << 'config.ru'
+  # Gemfile* and gemspec are included here to support
+  # running Bundler at gem install time.
+  s.files << 'Gemfile.base'
+  s.files << 'Gemfile'
+  s.files << 'Gemfile.lock'
+  s.files << 'Gemfile.on_prem'
+  s.files << 'Gemfile.on_prem.lock'
+  s.files << 'licenses.xml'
+  # License
+  s.files << 'LICENSE'
+  s.files << 'NOTICE'
+  s.files << __FILE__
+
+  s.executables  = ['3scale_backend', '3scale_backend_worker']
+  s.require_path = 'lib'
+
+  s.extensions = 'ext/mkrf_conf.rb'
+end

data/app/api/api.rb

@@ -0,0 +1,13 @@
+require_relative 'internal/internal'
+require_relative 'internal/services'
+require_relative 'internal/applications'
+require_relative 'internal/metrics'
+require_relative 'internal/usagelimits'
+require_relative 'internal/events'
+require_relative 'internal/alert_limits'
+require_relative 'internal/application_keys'
+require_relative 'internal/application_referrer_filters'
+require_relative 'internal/errors'
+require_relative 'internal/utilization'
+require_relative 'internal/service_tokens'
+require_relative 'internal/stats'

data/app/api/internal/alert_limits.rb

@@ -0,0 +1,32 @@
+require '3scale/backend/alert_limit'
+
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/alert_limits' do
+        get '/' do |service_id|
+          limits = AlertLimit.load_all(service_id)
+          { status: :found, alert_limits: limits.map(&:to_hash) }.to_json
+        end
+
+        post '/' do |service_id|
+          value = params.fetch(:alert_limit, {}).fetch(:value, nil)
+          limit = AlertLimit.save(service_id, value)
+          if limit
+            [201, headers, { status: :created, alert_limit: limit.to_hash }.to_json]
+          else
+            halt 400, { error: "alert limit is invalid" }.to_json
+          end
+        end
+
+        delete '/:value' do |service_id, value|
+          if AlertLimit.delete(service_id, value)
+            { status: :deleted }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'alert limit not found' }.to_json]
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/application_keys.rb

@@ -0,0 +1,49 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/applications/:app_id/keys' do
+        module ApplicationKeysHelper
+          def self.to_hash(app, value)
+            {
+              service_id: app.service_id,
+              app_id:     app.id,
+              value:      value,
+            }
+          end
+        end
+
+        before do
+          @app = Application.load(params[:service_id], params[:app_id])
+          respond_with_404 'application not found' unless @app
+        end
+
+        get '/' do |service_id, app_id|
+          keys = @app.keys.map do |key|
+            ApplicationKeysHelper.to_hash(@app, key)
+          end
+
+          { status: :found, application_keys: keys }.to_json
+        end
+
+        post '/' do |service_id, app_id|
+          value = params.fetch(:application_key, {}).fetch(:value, nil)
+          key   = { app_id: @app.id }
+          if value.nil? || value.empty?
+            key.merge!(value: @app.create_key)
+          else
+            key.merge!(value: @app.create_key(value))
+          end
+          [201, headers, { status: :created, application_key: key }.to_json]
+        end
+
+        delete '/:id' do |service_id, app_id, id|
+          if @app.delete_key(id)
+            { status: :deleted }.to_json
+          else
+            respond_with_404("application key not found")
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/application_referrer_filters.rb

@@ -0,0 +1,43 @@
+require 'base64'
+
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/applications/:app_id/referrer_filters' do
+        before do
+          @app = Application.load params[:service_id], params[:app_id]
+          respond_with_404 'application not found'  unless @app
+        end
+
+        get '' do
+          filters = @app.referrer_filters.sort
+          {status: :found, referrer_filters: filters}.to_json
+        end
+
+        post '' do
+          begin
+            value = params.fetch(:referrer_filter, nil)
+            filter = @app.create_referrer_filter(value)
+
+            [201, headers, {status: :created, referrer_filter: filter}.to_json]
+          rescue ReferrerFilterInvalid => e
+            respond_with_400 e
+          end
+        end
+
+        delete '/:value' do
+          filter = begin
+            Base64.urlsafe_decode64 params[:value]
+          rescue ArgumentError
+            params[:value]
+          end
+          @app.delete_referrer_filter filter
+
+          {status: :deleted}.to_json
+        end
+
+      end
+    end
+  end
+end
+

data/app/api/internal/applications.rb

@@ -0,0 +1,77 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/applications' do
+        get '/:id' do |service_id, id|
+          app = Application.load(service_id, id)
+          if app
+            { status: :found, application: app.to_hash }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'application not found' }.to_json]
+          end
+        end
+
+        post '/:id' do |service_id, id|
+          app_attrs = api_params Application
+          if Application.exists?(service_id, id)
+            halt 405, { status: :exists, error: 'application cannot be created, exists already' }.to_json
+          end
+          app_attrs[:service_id] = service_id
+          app_attrs[:id] = id
+          begin
+            app = Application.save(app_attrs)
+          rescue ApplicationHasNoState => e
+            [400, headers, { status: :bad_request, error: e.message }.to_json]
+          else
+            [201, headers, { status: :created, application: app.to_hash }.to_json]
+          end
+        end
+
+        put '/:id' do |service_id, id|
+          app_attrs = api_params Application
+          modified = Application.exists?(service_id, id)
+          app_attrs[:service_id] = service_id
+          app_attrs[:id] = id
+          begin
+            app = Application.save(app_attrs)
+          rescue ApplicationHasNoState => e
+            [400, headers, { status: :bad_request, error: e.message }.to_json]
+          else
+            { status: modified ? :modified : :created, application: app.to_hash }.to_json
+          end
+        end
+
+        delete '/:id' do |service_id, id|
+          begin
+            Application.delete(service_id, id)
+            { status: :deleted }.to_json
+          rescue ApplicationNotFound
+            [404, headers, { status: :not_found, error: 'application not found' }.to_json]
+          end
+        end
+
+        # XXX Old API. DEPRECATED.
+        #
+        # We will NOT be loading the whole app for the key requested, which we
+        # would probably do otherwise, since users are only marginal, do not
+        # need it anyway, and are to be removed in the future.
+        #
+        get '/key/:user_key' do |service_id, user_key|
+          id = Application.load_id_by_key(service_id, user_key)
+          halt 404, { status: :not_found, error: 'application key not found' }.to_json unless id
+          { status: :found, application: { id: id } }.to_json
+        end
+
+        put '/:id/key/:user_key' do |service_id, id, user_key|
+          Application.save_id_by_key(service_id, user_key, id)
+          { status: :modified, application: { id: id } }.to_json
+        end
+
+        delete '/key/:user_key' do |service_id, user_key|
+          Application.delete_id_by_key(service_id, user_key)
+          { status: :deleted }.to_json
+        end
+      end
+    end
+  end
+end

data/app/api/internal/errors.rb

@@ -0,0 +1,54 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/errors' do
+        before do
+          unless Service.exists?(params[:service_id])
+            respond_with_404('service not found')
+          end
+        end
+
+        get '/' do |service_id|
+          if params[:per_page] && params[:per_page].to_i <= 0
+            halt(400, { error: 'per_page needs to be > 0' }.to_json)
+          end
+
+          errors = ErrorStorage.list(service_id,
+                                     page: params[:page],
+                                     per_page: params[:per_page])
+          errors.each { |error| error[:timestamp] = error[:timestamp].to_s }
+          { status: :found, errors: errors,
+            count: ErrorStorage.count(service_id) }.to_json
+        end
+
+        delete '/' do |service_id|
+          ErrorStorage.delete_all(service_id)
+          { status: :deleted }.to_json
+        end
+
+        if define_private_endpoints?
+          # Receives a parameter 'errors' which is an Array of Strings
+          # representing error messages.
+          # In this endpoint, we create errors of the generic type Error to
+          # keep things simple because we do not care about the type.
+          # If this changes in the future we might need to create errors
+          # of other types such as: ProviderKeyInvalid, KeyInvalid...
+          post '/' do |service_id|
+            errors = params[:errors]
+
+            unless errors
+              halt 400, { status: :error,
+                          error: 'missing parameter \'errors\'' }.to_json
+            end
+
+            errors.each do |error|
+              ErrorStorage.store(service_id, Error.new(error))
+            end
+
+            [201, headers, { status: :created }.to_json]
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/events.rb

@@ -0,0 +1,42 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/events' do
+        get '/' do
+          { status: :found, events: EventStorage.list }.to_json
+        end
+
+        delete '/:id' do
+          result = EventStorage.delete(params[:id])
+          if result > 0
+            { status: :deleted }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'event not found' }.to_json]
+          end
+        end
+
+        delete '/' do
+          result = EventStorage.delete_range(params[:upto_id])
+          { status: :deleted, num_events: result }.to_json
+        end
+
+        if define_private_endpoints?
+          post '/' do
+            events = params[:events]
+
+            unless events
+              halt 400, { status: :error,
+                          error: 'missing parameter \'events\'' }.to_json
+            end
+
+            events.each do |event|
+              EventStorage.store(event[:type].to_sym, event[:object])
+            end
+
+            [201, headers, { status: :created }.to_json]
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/internal.rb

@@ -0,0 +1,104 @@
+require '3scale/backend/version'
+require 'sinatra/namespace'
+require 'json'
+
+module ThreeScale
+  module Backend
+    module API
+      class InvalidCredentials < RuntimeError
+        def initialize(msg = 'Internal API credentials not provided.'.freeze)
+          super(msg)
+        end
+      end
+
+      def self.internal_api(ns, &blk)
+        Internal.class_eval { namespace ns, &blk }
+      end
+
+      class Internal < Sinatra::Base
+
+        register Sinatra::Namespace
+
+        # using a class variable instead of settings because we want this to be
+        # as fast as possible when responding, since we hit /status a lot.
+        @@status = { status: :ok,
+                     version: { backend: ThreeScale::Backend::VERSION } }.to_json
+
+        before do
+          content_type 'application/json'
+          parse_json_params params
+        end
+
+        error Sinatra::NotFound do
+          { status: :not_found, error: 'Not found'}.to_json
+        end
+
+        get '/check.json' do
+          {status: :ok}.to_json
+        end
+
+        get '/status' do
+          @@status
+        end
+
+        def self.define_private_endpoints?
+          ThreeScale::Backend.test? || ThreeScale::Backend.development?
+        end
+
+        def initialize(username: nil, password: nil, allow_insecure: false)
+          @username = username
+          @password = password
+          raise InvalidCredentials unless allow_insecure or credentials_set?
+          super()
+        end
+
+        # the two methods below are used by the Rack application for auth
+        # you can access them through the .helpers method after calling .new
+        def credentials_set?
+          (!@username.nil? && !@username.empty?) ||
+              (!@password.nil? && !@password.empty?)
+        end
+
+        def check_password(username, password)
+          username == @username && password == @password
+        end
+
+        private
+
+        def parse_json_params(params)
+          body = request.body.read
+          params.merge! JSON.parse(body, symbolize_names: true) unless body.empty?
+        end
+
+        # Return hash with item keys from the white_list when
+        # request parameter value is not nil for the given key
+        def valid_request_attrs(req_attrs, white_list)
+          white_list.each_with_object({}) do |elem, res|
+            res[elem] = req_attrs[elem] unless req_attrs[elem].nil?
+          end
+        end
+
+        def api_params(klass, api_scope = nil)
+          api_scope ||= klass.name.split('::'.freeze).last.downcase
+          attributes = params[api_scope]
+          # Checked both key does not exist and key exists but nil stored
+          halt 400, { status: :error, error: "missing parameter '#{api_scope}'" }.to_json unless attributes
+          valid_request_attrs(attributes, klass.attribute_names)
+        end
+
+        def filter_params(params)
+          params.reject!{ |k, v| !ACCEPTED_PARAMS.include? k }
+        end
+
+        def respond_with_400(exception)
+          halt 400, {error: exception.message}.to_json
+        end
+
+        def respond_with_404(message)
+          halt 404, {status: :not_found, error: message}.to_json
+        end
+
+      end
+    end
+  end
+end