pisoni 1.23.1

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

@@ -0,0 +1,82 @@
+module ThreeScale
+  module Core
+    class Service < APIClient::Resource
+      attributes :provider_key, :id, :backend_version, :referrer_filters_required,
+                 :user_registration_required, :default_user_plan_id,
+                 :default_user_plan_name, :default_service
+
+      class << self
+        def load_by_id(service_id)
+          api_read({}, uri: service_uri(service_id), rprefix: :service)
+        end
+
+        def delete_by_id!(service_id)
+          api_delete({}, uri: service_uri(service_id)) do |result|
+            if result[:response].status == 400
+              raise ServiceIsDefaultService, service_id
+            end
+          end
+        end
+
+        def save!(attributes)
+          id = attributes.fetch(:id)
+          api_update(attributes, uri: service_uri(id)) do |result|
+            if result[:response].status == 400
+              raise ServiceRequiresDefaultUserPlan
+            end
+            true
+          end
+        end
+
+        def change_provider_key!(old_key, new_key)
+          ret = api_do_put({ new_key: new_key },
+                           uri: "#{default_uri}change_provider_key/#{old_key}",
+                           prefix: '') do |result|
+            if result[:response].status == 400
+              exception = provider_key_exception(
+                  result[:response_json][:error], old_key, new_key)
+              raise exception if exception
+            end
+            true
+          end
+          ret[:ok]
+        end
+
+        def make_default(service_id)
+          save! id: service_id, default_service: true
+        end
+
+        private
+
+        def service_uri(id)
+          "#{default_uri}#{id}"
+        end
+
+        def provider_key_exception(error, old_key, new_key)
+          case error
+          when /does not exist/
+            ProviderKeyNotFound.new old_key
+          when /already exists/
+            ProviderKeyExists.new new_key
+          when /are not valid/
+            InvalidProviderKeys.new
+          else
+            nil
+          end
+        end
+      end
+
+      def referrer_filters_required?
+        @referrer_filters_required
+      end
+
+      def user_registration_required?
+        @user_registration_required
+      end
+
+      def save!
+        self.class.save! attributes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ThreeScale
+  module Core
+    class ServiceError < APIClient::Resource
+      attributes :code, :message, :timestamp
+
+      default_uri '/internal/services/'
+
+      def self.service_errors_uri(service_id)
+        "#{default_uri}#{service_id}/errors/"
+      end
+      private_class_method :service_errors_uri
+
+      def self.load_all(service_id, options={})
+        result = api_do_get(options,
+                            { uri: service_errors_uri(service_id),
+                              prefix: '',
+                              rprefix: :errors }) do |result|
+          if result[:response].status == 400 &&
+              result[:response_json][:error] == 'per_page needs to be > 0'
+            raise InvalidPerPage.new
+          end
+          true
+        end
+
+        APIClient::Collection.new(result[:attributes].map { |attrs| new attrs },
+                                  result[:response_json][:count])
+      end
+
+      def self.delete_all(service_id)
+        api_delete({}, uri: service_errors_uri(service_id))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module ThreeScale
+  module Core
+    class ServiceToken < APIClient::Resource
+
+      default_uri '/internal/service_tokens/'
+
+      class << self
+
+        def save!(attributes)
+          api_do_post(attributes, prefix: :service_tokens) do |result|
+
+            status = result[:response].status
+
+            if status == 400
+              raise ServiceTokenMissingParameter, result[:response_json][:error]
+            end
+
+            if status == 422
+              case result[:response_json][:error]
+              when /Service ID/
+                raise ServiceTokenRequiresServiceId
+              when /Service token/
+                raise ServiceTokenRequiresToken
+              end
+            end
+
+            true
+          end
+        end
+
+        def delete(attributes)
+          result = api_do_delete(attributes, uri: default_uri, prefix: :service_tokens)
+
+          result[:response_json][:count]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ThreeScale
+  module Core
+    class Transaction < APIClient::Resource
+      attributes :application_id, :usage, :timestamp
+
+      default_uri '/internal/services/'
+
+      def self.transactions_uri(service_id)
+        "#{default_uri}#{service_id}/transactions/"
+      end
+      private_class_method :transactions_uri
+
+      def self.load_all(service_id)
+        result = api_do_get({}, { uri: transactions_uri(service_id),
+                                  rprefix: :transactions })  do |result|
+          return nil if result[:response].status == 404
+          true
+        end
+
+        return nil if result.nil?
+
+        APIClient::Collection.new(result[:attributes].map { |attrs| new attrs })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module ThreeScale
+  module Core
+    class UsageLimit < APIClient::Resource
+      PERIODS = [:eternity, :year, :month, :week, :day, :hour, :minute].freeze
+
+      attributes :service_id, :plan_id, :metric_id, :value, *PERIODS
+
+      default_uri '/internal/services/'
+
+      def self.base_uri(service_id, plan_id, metric_id, period)
+        "#{default_uri}#{service_id}/plans/#{plan_id}/usagelimits/#{metric_id}/#{period}"
+      end
+      private_class_method :base_uri
+
+      def self.load_value(service_id, plan_id, metric_id, period)
+        obj = api_read({}, uri: base_uri(service_id, plan_id, metric_id, period))
+        obj and obj.public_send(period).to_i
+      end
+
+      def self.save(attributes)
+        # save currently DOES NOT support multiple periods at the same time,
+        # since it would mean multiple API calls per call to this method.
+        periodlst = PERIODS & attributes.keys
+        raise UsageLimitInvalidPeriods.new(periodlst) unless periodlst.one?
+
+        service_id, plan_id, metric_id = attributes.fetch(:service_id), attributes.fetch(:plan_id), attributes.fetch(:metric_id)
+        period = periodlst.shift
+        value = attributes[period]
+        fixed_fields = { service_id: service_id, plan_id: plan_id, metric_id: metric_id }.freeze
+
+        api_update(fixed_fields.merge({period => value}), uri: base_uri(service_id, plan_id, metric_id, period))
+      end
+
+      def self.delete(service_id, plan_id, metric_id, period)
+        api_delete({}, uri: base_uri(service_id, plan_id, metric_id, period))
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module ThreeScale
+  module Core
+    class User < APIClient::Resource
+      attributes :service_id, :username, :state, :plan_id, :plan_name
+
+      default_uri '/internal/services/'
+
+      def self.base_uri(service_id, username)
+        "#{default_uri}#{service_id}/users/#{username}"
+      end
+      private_class_method :base_uri
+
+      def self.check_params(service_id, username)
+        raise UserRequiresUsername if username.nil? || username == ''.freeze
+        raise UserRequiresServiceId if service_id.nil? || service_id == ''.freeze
+      end
+      private_class_method :check_params
+
+      def self.load(service_id, username)
+        check_params service_id, username
+        api_read({}, uri: base_uri(service_id, username))
+      end
+
+      def self.save!(attributes)
+        service_id, username = attributes[:service_id], attributes[:username]
+        check_params service_id, username
+        api_update(attributes,
+                   uri: base_uri(service_id, username)) do |result|
+          if result[:response].status == 400
+            if result[:response_json][:error] =~ /requires a valid service/
+              raise UserRequiresValidServiceId.new(service_id)
+            elsif result[:response_json][:error] =~ /requires a defined plan/
+              raise UserRequiresDefinedPlan.new(attributes[:plan_id],
+                                                attributes[:plan_name])
+            end
+          end
+          true
+        end
+      end
+
+      def self.delete!(service_id, username)
+        check_params service_id, username
+        api_delete({}, uri: base_uri(service_id, username))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ThreeScale
+  module Core
+    class Utilization < APIClient::Resource
+      attributes :period, :metric_name, :max_value, :current_value
+
+      default_uri '/internal/services/'
+
+      def self.utilization_uri(service_id, app_id)
+        "#{default_uri}#{service_id}/applications/#{app_id}/utilization/"
+      end
+      private_class_method :utilization_uri
+
+      def self.load(service_id, app_id)
+        result = api_do_get({},
+                            uri: utilization_uri(service_id, app_id),
+                            rprefix: :utilization) do |result|
+          return nil if result[:response].status == 404
+          true
+        end
+
+        return nil if result.nil?
+
+        usage_reports = result[:attributes].map { |attrs| new attrs }
+        APIClient::Collection.new(usage_reports)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module ThreeScale
+  module Core
+    VERSION = '1.23.1'
+  end
+end

data/lib/3scale/core.rb

@@ -0,0 +1,63 @@
+require 'uri'
+require 'json'
+require 'faraday'
+
+require '3scale/core/version'
+require '3scale/core/logger'
+
+require '3scale/core/api_client'
+require '3scale/core/application'
+require '3scale/core/metric'
+require '3scale/core/service'
+require '3scale/core/usage_limit'
+require '3scale/core/user'
+require '3scale/core/event'
+require '3scale/core/alert_limit'
+require '3scale/core/errors'
+require '3scale/core/application_key'
+require '3scale/core/application_referrer_filter'
+require '3scale/core/service_error'
+require '3scale/core/transaction'
+require '3scale/core/utilization'
+require '3scale/core/service_token'
+
+module ThreeScale
+  module Core
+    extend self
+
+    attr_accessor :username, :password
+    attr_writer :url
+
+    def faraday
+      return @faraday if @faraday
+
+      url = self.url
+      @faraday = Faraday.new(url: url) do |f|
+        f.adapter :net_http_persistent
+      end
+      @faraday.headers = {
+        'User-Agent' => "pisoni v#{ThreeScale::Core::VERSION}",
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json'
+      }
+
+      if @username.nil? && @password.nil?
+        # even though the url may contain the user info, turns out Faraday is
+        # not really picking it up, so must fill it in if present in the URL and
+        # no previous setting was done (ie. assigning username or password).
+        uri = URI.parse url
+        @username = uri.user
+        @password = uri.password
+      end
+
+      @faraday.basic_auth(@username, @password) if @username || @password
+      @faraday
+    end
+
+    def url
+      ENV['THREESCALE_CORE_INTERNAL_API'] || @url ||
+        raise(UnknownAPIEndpoint)
+    end
+
+  end
+end

data/lib/3scale_core.rb

@@ -0,0 +1 @@
+require '3scale/core'

data/lib/pisoni.rb

@@ -0,0 +1,5 @@
+require '3scale/core'
+
+module Pisoni
+  include ThreeScale::Core
+end

data/pisoni.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require '3scale/core/version'
+
+Gem::Specification.new do |s|
+  s.name = 'pisoni'
+  s.version = ThreeScale::Core::VERSION
+  s.date = Time.now.utc.strftime('%Y-%m-%d')
+
+  s.platform = Gem::Platform::RUBY
+
+  s.authors = ['Alejandro Martinez Ruiz']
+  s.email = %w[alex@3scale.net]
+
+  s.homepage = 'https://github.com/3scale/pisoni'
+  s.summary = 'Client for the Apisonator internal API for model data'
+  s.description = 'Client for the Apisonator internal API for model data.'
+  s.license     = 'Apache-2.0'
+
+  s.add_dependency 'faraday', '~> 0.13.1'
+  s.add_dependency 'json', '~> 1.8.1'
+  s.add_dependency 'injectedlogger', '~> 0.0.13'
+  s.add_dependency 'net-http-persistent'
+
+  s.add_development_dependency 'rake'
+
+  s.files         = `git ls-files`.split($/).reject do |f| [
+                        %r{^\.[^\/]},
+                        %r{^script/},
+                        %r{^docker/},
+                        %r{^mk/},
+                      ].any? { |r| r.match f }
+                    end
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+
+  s.require_paths = ["lib"]
+
+  s.rdoc_options = ["--charset=UTF-8"]
+
+  s.required_ruby_version = '>= 2.2.4'
+end

data/spec/alert_limit_spec.rb

@@ -0,0 +1,72 @@
+require_relative './spec_helper'
+module ThreeScale
+  module Core
+    describe AlertLimit do
+      describe '.load_all' do
+        describe 'when there are alert limits' do
+          let(:service_id) { 100 }
+          let(:values)     { [50, 100] }
+          before do
+            values.map { |value| AlertLimit.delete(service_id, value) }
+            values.map { |value| AlertLimit.save(service_id, value) }
+          end
+
+          it 'returns a list of alert limits' do
+            alert_limits = AlertLimit.load_all(service_id)
+
+            alert_limits.size.must_equal 2
+            alert_limits.map(&:value).must_equal values
+          end
+        end
+
+        describe 'when there are no alert limits' do
+          let(:service_id) { 200 }
+
+          it 'returns an empty list' do
+            AlertLimit.load_all(service_id).must_equal []
+          end
+        end
+      end
+
+      describe '.save' do
+        let(:service_id) { 500 }
+        let(:value)      { 100 }
+
+        before do
+          AlertLimit.delete(service_id, value)
+        end
+
+        it 'returns a AlertLimit object' do
+          alert_limit = AlertLimit.save(service_id, value)
+
+          alert_limit.must_be_kind_of AlertLimit
+          alert_limit.value.must_equal value
+        end
+      end
+
+      describe '.delete' do
+        describe 'with an existing alert limit' do
+          let(:service_id) { 300 }
+          let(:value)      { 50 }
+
+          before do
+            AlertLimit.save(service_id, value)
+          end
+
+          it 'returns true' do
+            AlertLimit.delete(service_id, value).must_equal true
+          end
+        end
+
+        describe 'with a non-existing alert limit' do
+          let(:service_id) { 300 }
+          let(:value)      { 75  }
+
+          it 'returns true' do
+            AlertLimit.delete(service_id, value).must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/application_key_spec.rb

@@ -0,0 +1,97 @@
+require_relative './spec_helper'
+module ThreeScale
+  module Core
+    describe ApplicationKey do
+      describe '.load_all' do
+        describe 'when there are application keys' do
+          let(:service_id) { 100 }
+          let(:app_id)     { 2001 }
+          let(:values)     { ["foo", "bar"] }
+          before do
+            values.map { |value| ApplicationKey.delete(service_id, app_id, value) }
+
+            Application.save service_id: service_id, id: app_id, state: 'suspended',
+                             plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+
+            values.map { |value| ApplicationKey.save(service_id, app_id, value) }
+          end
+
+          it 'returns a list of application keys' do
+            application_keys = ApplicationKey.load_all(service_id, app_id)
+
+            application_keys.size.must_equal 2
+            application_keys.map(&:value).sort.must_equal values.sort
+          end
+        end
+
+        describe 'when there are no application keys' do
+          let(:service_id) { 200 }
+          let(:app_id)     { 300 }
+
+          before do
+            Application.save service_id: service_id, id: app_id, state: 'suspended',
+                             plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+          end
+
+          it 'returns an empty list' do
+            ApplicationKey.load_all(service_id, app_id).must_equal []
+          end
+        end
+      end
+
+      describe '.save' do
+        let(:service_id) { 500 }
+        let(:app_id)     { 500 }
+        let(:value)      { "foobar" }
+
+        before do
+          ApplicationKey.delete(service_id, app_id, value)
+
+          Application.save service_id: service_id, id: app_id, state: 'suspended',
+                           plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+        end
+
+        it 'returns an ApplicationKey object' do
+          application_key = ApplicationKey.save(service_id, app_id, value)
+
+          application_key.must_be_kind_of ApplicationKey
+          application_key.value.must_equal value
+        end
+      end
+
+      describe '.delete' do
+        describe 'with an existing application key' do
+          let(:service_id) { 300 }
+          let(:app_id)     { 200 }
+          let(:value)      { "foo" }
+
+          before do
+            Application.save service_id: service_id, id: app_id, state: 'suspended',
+                             plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+
+            ApplicationKey.save(service_id, app_id, value)
+          end
+
+          it 'returns true' do
+            ApplicationKey.delete(service_id, app_id, value).must_equal true
+          end
+        end
+
+        describe 'with a non-existing application key' do
+          let(:service_id) { 300 }
+          let(:app_id)     { 500 }
+          let(:value)      { "nonexistingkey" }
+
+          before do
+            Application.save service_id: service_id, id: app_id, state: 'suspended',
+                             plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+          end
+
+          it 'returns true' do
+            ApplicationKey.delete(service_id, app_id, value).must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/application_referrer_filter_spec.rb

@@ -0,0 +1,57 @@
+require_relative './spec_helper'
+module ThreeScale
+  module Core
+    describe ApplicationReferrerFilter do
+      let(:service_id) { 10 }
+      let(:app_id)     { 100 }
+      let(:filters) { %w(foo bar doopah) }
+      let(:application) do
+        { service_id: service_id,
+          id: app_id,
+          state: 'suspended',
+          plan_id: '3066',
+          plan_name: 'crappy',
+          redirect_url: 'blah' }
+      end
+
+      before do
+        filters.map do |filter|
+          ApplicationReferrerFilter.delete(service_id, app_id, filter)
+        end
+
+        Application.delete(service_id, app_id)
+        Application.save(application)
+      end
+
+      describe '.load_all' do
+        describe 'Getting all referrer filters' do
+          let(:values)     { %w(foo bar) }
+
+          before do
+            values.map { |value| ApplicationReferrerFilter.save(service_id, app_id, value) }
+          end
+
+          it 'returns a sorted list of filters' do
+            filters = ApplicationReferrerFilter.load_all(service_id, app_id)
+            filters.must_equal values.sort
+          end
+        end
+
+        describe 'when there are no referrer filters' do
+          it 'returns an empty list' do
+            ApplicationReferrerFilter.load_all(service_id, app_id).must_equal []
+          end
+        end
+      end
+
+      describe '.save' do
+        let(:filter) { 'doopah' }
+
+        it 'saves the filter' do
+          ApplicationReferrerFilter.save(service_id, app_id, filter)
+          ApplicationReferrerFilter.load_all(service_id, app_id).must_equal([filter])
+        end
+      end
+    end
+  end
+end