arkaan 1.4.7 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf1b485990b9b205c0ec44f7b8ba3139c7d2e013
-  data.tar.gz: 241f47f572cf1684690063588dda394e53290dba
+  metadata.gz: c39aa671150c915b8a1b26d7bc4ec8101eaa3128
+  data.tar.gz: 47aecda9bdc9b5a2973687d8a732c4fe029522d5
 SHA512:
-  metadata.gz: 74769ac2754786ff14dda033668f4c74a94e986160b689a1336b1213a550fe76a4b0a0f0162ca8589421dcc32d6c67aa13db02857fec491179ad9408f920b926
-  data.tar.gz: da2aac145bb6b69bdbf3eb9d3289ef8f7376a496a25c465a417cd95dc15ac71c0495c2a13b52affac6ad33590ab564c33536f5060c5e53029442aabf4b003ad8
+  metadata.gz: a7585c99ec2d678ce02a022b494793b6d28a929ac903121c90fe91ea4459079140cce09991e546c7ab52a2c0ad8e6860ecf2a1c875a0e7327ae8c3bab924f284
+  data.tar.gz: 94defbac662fe38f06ed30a557f7ee4dd50f1a5021989ba52ebfd7338d7fbc01c634e7407473389188b85f97de4c2392bbe3bd376d677b0004cef65c22a72514

data/lib/arkaan/utils.rb

@@ -2,9 +2,9 @@ module Arkaan
   # Utility classes for the different micro-services of the suite.
   # @author Vincent Courtois <courtois.vincent@outlook.com>
   module Utils
-    autoload :Controller             , 'arkaan/utils/controller'
-    autoload :ControllerWithoutFilter, 'arkaan/utils/controller_without_filter'
-    autoload :Errors                 , 'arkaan/utils/errors'
-    autoload :MicroService           , 'arkaan/utils/micro_service'
+    autoload :Controllers , 'arkaan/utils/controllers'
+    autoload :Errors      , 'arkaan/utils/errors'
+    autoload :Loaders     , 'arkaan/utils/loaders'
+    autoload :MicroService, 'arkaan/utils/micro_service'
   end
 end

data/lib/arkaan/utils/controllers.rb

@@ -0,0 +1,8 @@
+module Arkaan
+  module Utils
+    module Controllers
+      autoload :Base   , 'arkaan/utils/controllers/base'
+      autoload :Checked, 'arkaan/utils/controllers/checked'
+    end
+  end
+end

data/lib/arkaan/utils/controllers/base.rb

@@ -0,0 +1,193 @@
+module Arkaan
+  module Utils
+    module Controllers
+      # Base controller to handle the standard error when accessing the API.
+      # @author Vincent Courtois <courtois.vincenet@outlook.com>
+      class Base < Sinatra::Base
+        register Sinatra::ConfigFile
+        helpers Sinatra::CustomLogger
+
+        configure do
+          set :logger, Logger.new(STDOUT)
+          logger.level = Logger::ERROR if ENV['RACK_ENV'] == 'test'
+        end
+
+        # Creates a premium route whithin the Sinatra application, and registers it in the database if it does not already exists.
+        # @param verb [String] the HTTP method used to create this route.
+        # @param path [String] the path, beginning with a /, of the route to create.
+        def self.declare_route(verb, path, options: {}, &block)
+          self.declare_route_with(verb, path, false, options, &block)
+        end
+
+        # Creates a non premium route whithin the Sinatra application, and registers it in the database if it does not already exists.
+        # @param verb [String] the HTTP method used to create this route.
+        # @param path [String] the path, beginning with a /, of the route to create.
+        def self.declare_premium_route(verb, path, options: {}, &block)
+          self.declare_route_with(verb, path, true, options, &block)
+        end
+
+        # Creates a route whithin the Sinatra application, and registers it in the database if it does not already exists.
+        # @param verb [String] the HTTP method used to create this route.
+        # @param path [String] the path, beginning with a /, of the route to create.
+        # @param premium [Boolean] TRUE to make the route premium, FALSE otherwise.
+        def self.declare_route_with(verb, path, premium, options, &block)
+          service = Arkaan::Utils::MicroService.instance.service
+          complete_path = "#{Arkaan::Utils::MicroService.instance.path}#{path == '/' ? '' : path}"
+
+          unless service.nil? || !service.routes.where(path: path, verb: verb).first.nil?
+            route = Arkaan::Monitoring::Route.create(path: path, verb: verb, premium: premium, service: service)
+            if !options.nil? && !options[:authenticated].nil?
+              route.update_attribute(:authenticated, false)
+            end
+            Arkaan::Permissions::Group.where(is_superuser: true).each do |group|
+              group.routes << route
+              group.save!
+            end
+          end
+          if premium
+            self.public_send(verb, complete_path) do
+              @sinatra_route = parse_current_route
+              if !@application.premium?
+                custom_error(403, 'common.app_key.forbidden')
+              end
+              instance_eval(&block)
+            end
+          else
+            logger.info "#{verb} #{complete_path}"
+            self.public_send(verb, complete_path, &block)
+          end
+        end
+
+        # Loads the errors configuration file from the config folder.
+        # @param file [String] send __FILE__
+        def self.load_errors_from(file)
+          config_file File.join(File.dirname(file), '..', 'config', 'errors.yml')
+        end
+
+        def before_checks
+          add_body_to_params
+
+          check_presence('token', 'app_key', route: 'common')
+
+          gateway = Arkaan::Monitoring::Gateway.where(token: params['token']).first
+          @application = Arkaan::OAuth::Application.where(key: params['app_key']).first
+          
+          if gateway.nil?
+            custom_error(404, 'common.token.unknown')
+          elsif @application.nil?
+            custom_error(404, 'common.app_key.unknown')
+          end
+        end
+
+        # Checks the presence of several fields given as parameters and halts the execution if it's not present.
+        # @param fields [Array<String>] an array of fields names to search in the parameters
+        # @param route [String] the name of the route you're requiring to put in the error message.
+        def check_presence(*fields, route:)
+          fields.each do |field|
+            custom_error(400, "#{route}.#{field}.required") if params[field].nil? || params[field] == ''
+          end
+        end
+
+        # Checks the presence of either fields given in parameters. It halts with an error only if ALL parameters are not given.
+        # @param fields [Array<String>] an array of fields names to search in the parameters
+        # @param route [String] the name of the route you're requiring to put in the error message.
+        # @param key [String] the key to search in the errors configuration file.
+        def check_either_presence(*fields, route:, key:)
+          fields.each do |field|
+            return true if !params[field].nil? && params[field] != ''
+          end
+          custom_error 400, "#{route}.#{key}.required"
+        end
+
+        # Checks if the session ID is given in the parameters and if the session exists.
+        # @param action [String] the action used to get the errors from the errors file.
+        # @return [Arkaan::Authentication::Session] the session when it exists.
+        def check_session(action)
+          check_presence('session_id', route: action)
+          session = Arkaan::Authentication::Session.where(token: params['session_id']).first
+          if session.nil?
+            custom_error(404, "#{action}.session_id.unknown")
+          end
+          return session
+        end
+
+        def check_application(action)
+          check_presence('app_key', route: action)
+          application = Arkaan::OAuth::Application.where(key: params['app_key']).first
+          custom_error(404, "#{action}.app_key.unknown") if application.nil?
+          return application
+        end
+
+        # Adds the parsed body to the parameters, overwriting the parameters of the querystring with the values
+        # of the SON body if they have similar keys.
+        def add_body_to_params
+          if request.body.respond_to?(:rewind) && request.body.respond_to?(:read)
+            request.body.rewind 
+            parsed_body = JSON.parse(request.body.read.to_s) rescue {}
+            parsed_body.keys.each do |key|
+              params[key] = parsed_body[key]
+            end
+          end
+        end
+
+        # Gets the current route in the database from the sinatra route.
+        # @return [Arkaan::Monitoring::Route] the route declared in the services registry.
+        def parse_current_route
+          splitted = request.env['sinatra.route'].split(' ')
+          return Arkaan::Monitoring::Route.where(verb: splitted.first.downcase, path: splitted.last).first
+        end
+
+        # Halts the application and creates the returned body from the parameters and the errors config file.
+        # @param status [Integer] the HTTP status to halt the application with.
+        # @param path [String] the path in the configuration file to access the URL.
+        def custom_error(status, path)
+          route, field, error = path.split('.')
+          docs = settings.errors[route][field][error] rescue ''
+          halt status, {status: status, field: field, error: error, docs: docs}.to_json
+        end
+
+        # Halts the application with a Bad Request error affecting a field of a model.
+        # @param instance [Mongoid::Document] the document having a field in error.
+        # @param route [String] the type of action you're currently doing (e.g: 'creation')
+        def model_error(instance, route)
+          messages = instance.errors.messages
+          field = messages.keys.first
+          custom_error(400, "#{route}.#{field}.#{messages[field].first}")
+        end
+
+        # Select parameters in the params hash, by its keys.
+        # @param fields [Array<String>] the keys to select in the params hash.
+        # @return [Hash] the selected chunk of the params hash.
+        def select_params(*fields)
+          return params.select { |key, value| fields.include?(key) }
+        end
+
+        # Creates a custom error from an existing Arkaan exception class.
+        # @param exception {StandardError} the exception to transform in a usable error.
+        def handle_arkaan_exception(exception)
+          custom_error(exception.status, "#{exception.action}.#{exception.field}.#{exception.error}")
+        end
+
+        error Arkaan::Utils::Errors::BadRequest do |exception|
+          handle_arkaan_exception(exception)
+        end
+
+        error Arkaan::Utils::Errors::Forbidden do |exception|
+          handle_arkaan_exception(exception)
+        end
+
+        error Arkaan::Utils::Errors::NotFound do |exception|
+          handle_arkaan_exception(exception)
+        end
+
+        error Arkaan::Factories::Errors::GatewayNotFound do |exception|
+          handle_arkaan_exception(exception)
+        end
+
+        error StandardError do |exception|
+          custom_error(500, 'system_error.unknown_field.unknown_error')
+        end
+      end
+    end
+  end
+end

data/lib/arkaan/utils/controllers/checked.rb

@@ -0,0 +1,14 @@
+module Arkaan
+  module Utils
+    module Controllers
+      # Base controller to handle the standard error when accessing the API.
+      # @author Vincent Courtois <courtois.vincenet@outlook.com>
+      class Checked < Arkaan::Utils::Controllers::Base
+
+        before do
+          before_checks
+        end
+      end
+    end
+  end
+end

data/lib/arkaan/utils/loaders.rb

@@ -0,0 +1,7 @@
+module Arkaan
+  module Utils
+    module Loaders
+      autoload :Heroku, 'arkaaan/utils/loaders/heroku'
+    end
+  end
+end

data/lib/arkaan/utils/loaders/heroku.rb

@@ -0,0 +1,20 @@
+module Arkaan
+  module Utils
+    module Plugins
+      class Heroku
+        # Loads the heroku informations inside the data of the instance.
+        # @param instance [Arkaan::Monitoring::Instance] the instance to put the enrichment inside.
+        def self.load!(instance)
+          if !ENV['OAUTH_TOKEN'].nil? && instance != false && instance.persisted?
+            heroku = PlatformAPI.connect_oauth(ENV['OAUTH_TOKEN'])
+            regex = /\Ahttps?:\/\/([a-z\-]+).herokuapp.com\/?\z/
+            if instance.url.match(regex)
+              app_name = instance.url.scan(regex).first.first
+              instance.update_attribute(:data, heroku.app.info(app_name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkaan/utils/micro_service.rb

@@ -108,10 +108,10 @@ module Arkaan
       # @return [Arkaan::Monitoring::Instance] the instance of the micro service currently running.
       def register_instance
         @instance = @service.instances.where(url: ENV['SERVICE_URL']).first
-        if instance.nil?
+        if @instance.nil?
           @instance = Arkaan::Monitoring::Instance.create(service: @service, url: ENV['SERVICE_URL'], type: type)
         end
-        instance.update_attribute(:running, true)
+        @instance.update_attribute(:running, true)
         return @instance
       end
 
@@ -128,7 +128,7 @@ module Arkaan
             @service.update_attribute(:test_mode, true)
           end
           register_instance
-          get_heroku_infos if type == :heroku && !test_mode
+          load_plugin!
           if service
             load_standard_files
             load_test_files if test_mode
@@ -137,16 +137,11 @@ module Arkaan
         return self
       end
 
-      def get_heroku_infos
-        if !ENV['OAUTH_TOKEN'].nil? && instance != false && instance.persisted?
-          heroku = PlatformAPI.connect_oauth(ENV['OAUTH_TOKEN'])
-          regex = /\Ahttps?:\/\/([a-z\-]+).herokuapp.com\/?\z/
-          if instance.url.match(regex)
-            app_name = instance.url.scan(regex).first.first
-            instance.update_attribute(:data, heroku.app.info(app_name))
-          end
+      def load_plugin!
+        plugin = ENV['ADDITIONAL_PLUGIN']
+        if !plugin.nil? && Arkaan::Utils::Plugins.constants.include?(plugin)
+          Arkaan::Utils::Plugins.const_get(plugin).load!(@instance)
         end
-        return self
       end
 
       def load_mongoid_configuration(test_mode: false)

data/lib/arkaan/version.rb

@@ -0,0 +1,3 @@
+module Arkaan
+  VERSION = '1.5.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arkaan
 version: !ruby/object:Gem::Version
-  version: 1.4.7
+  version: 1.5.0
 platform: ruby
 authors:
 - Vincent Courtois
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-18 00:00:00.000000000 Z
+date: 2019-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -325,15 +325,19 @@ files:
 - lib/arkaan/rulesets/fields/integer.rb
 - lib/arkaan/specs.rb
 - lib/arkaan/utils.rb
-- lib/arkaan/utils/controller.rb
-- lib/arkaan/utils/controller_without_filter.rb
+- lib/arkaan/utils/controllers.rb
+- lib/arkaan/utils/controllers/base.rb
+- lib/arkaan/utils/controllers/checked.rb
 - lib/arkaan/utils/errors.rb
 - lib/arkaan/utils/errors/bad_request.rb
 - lib/arkaan/utils/errors/forbidden.rb
 - lib/arkaan/utils/errors/http_error.rb
 - lib/arkaan/utils/errors/not_found.rb
+- lib/arkaan/utils/loaders.rb
+- lib/arkaan/utils/loaders/heroku.rb
 - lib/arkaan/utils/micro_service.rb
 - lib/arkaan/utils/seeder.rb
+- lib/arkaan/version.rb
 homepage: https://rubygems.org/gems/arkaan
 licenses:
 - MIT

data/lib/arkaan/utils/controller.rb

@@ -1,12 +0,0 @@
-module Arkaan
-  module Utils
-    # Base controller to handle the standard error when accessing the API.
-    # @author Vincent Courtois <courtois.vincenet@outlook.com>
-    class Controller < Arkaan::Utils::ControllerWithoutFilter
-
-      before do
-        before_checks
-      end
-    end
-  end
-end

data/lib/arkaan/utils/controller_without_filter.rb

@@ -1,191 +0,0 @@
-module Arkaan
-  module Utils
-    # Base controller to handle the standard error when accessing the API.
-    # @author Vincent Courtois <courtois.vincenet@outlook.com>
-    class ControllerWithoutFilter < Sinatra::Base
-      register Sinatra::ConfigFile
-      helpers Sinatra::CustomLogger
-
-      configure do
-        set :logger, Logger.new(STDOUT)
-        logger.level = Logger::ERROR if ENV['RACK_ENV'] == 'test'
-      end
-
-      # Creates a premium route whithin the Sinatra application, and registers it in the database if it does not already exists.
-      # @param verb [String] the HTTP method used to create this route.
-      # @param path [String] the path, beginning with a /, of the route to create.
-      def self.declare_route(verb, path, options: {}, &block)
-        self.declare_route_with(verb, path, false, options, &block)
-      end
-
-      # Creates a non premium route whithin the Sinatra application, and registers it in the database if it does not already exists.
-      # @param verb [String] the HTTP method used to create this route.
-      # @param path [String] the path, beginning with a /, of the route to create.
-      def self.declare_premium_route(verb, path, options: {}, &block)
-        self.declare_route_with(verb, path, true, options, &block)
-      end
-
-      # Creates a route whithin the Sinatra application, and registers it in the database if it does not already exists.
-      # @param verb [String] the HTTP method used to create this route.
-      # @param path [String] the path, beginning with a /, of the route to create.
-      # @param premium [Boolean] TRUE to make the route premium, FALSE otherwise.
-      def self.declare_route_with(verb, path, premium, options, &block)
-        service = Arkaan::Utils::MicroService.instance.service
-        complete_path = "#{Arkaan::Utils::MicroService.instance.path}#{path == '/' ? '' : path}"
-
-        unless service.nil? || !service.routes.where(path: path, verb: verb).first.nil?
-          route = Arkaan::Monitoring::Route.create(path: path, verb: verb, premium: premium, service: service)
-          if !options.nil? && !options[:authenticated].nil?
-            route.update_attribute(:authenticated, false)
-          end
-          Arkaan::Permissions::Group.where(is_superuser: true).each do |group|
-            group.routes << route
-            group.save!
-          end
-        end
-        if premium
-          self.public_send(verb, complete_path) do
-            @sinatra_route = parse_current_route
-            if !@application.premium?
-              custom_error(403, 'common.app_key.forbidden')
-            end
-            instance_eval(&block)
-          end
-        else
-          logger.info "#{verb} #{complete_path}"
-          self.public_send(verb, complete_path, &block)
-        end
-      end
-
-      # Loads the errors configuration file from the config folder.
-      # @param file [String] send __FILE__
-      def self.load_errors_from(file)
-        config_file File.join(File.dirname(file), '..', 'config', 'errors.yml')
-      end
-
-      def before_checks
-        add_body_to_params
-
-        check_presence('token', 'app_key', route: 'common')
-
-        gateway = Arkaan::Monitoring::Gateway.where(token: params['token']).first
-        @application = Arkaan::OAuth::Application.where(key: params['app_key']).first
-        
-        if gateway.nil?
-          custom_error(404, 'common.token.unknown')
-        elsif @application.nil?
-          custom_error(404, 'common.app_key.unknown')
-        end
-      end
-
-      # Checks the presence of several fields given as parameters and halts the execution if it's not present.
-      # @param fields [Array<String>] an array of fields names to search in the parameters
-      # @param route [String] the name of the route you're requiring to put in the error message.
-      def check_presence(*fields, route:)
-        fields.each do |field|
-          custom_error(400, "#{route}.#{field}.required") if params[field].nil? || params[field] == ''
-        end
-      end
-
-      # Checks the presence of either fields given in parameters. It halts with an error only if ALL parameters are not given.
-      # @param fields [Array<String>] an array of fields names to search in the parameters
-      # @param route [String] the name of the route you're requiring to put in the error message.
-      # @param key [String] the key to search in the errors configuration file.
-      def check_either_presence(*fields, route:, key:)
-        fields.each do |field|
-          return true if !params[field].nil? && params[field] != ''
-        end
-        custom_error 400, "#{route}.#{key}.required"
-      end
-
-      # Checks if the session ID is given in the parameters and if the session exists.
-      # @param action [String] the action used to get the errors from the errors file.
-      # @return [Arkaan::Authentication::Session] the session when it exists.
-      def check_session(action)
-        check_presence('session_id', route: action)
-        session = Arkaan::Authentication::Session.where(token: params['session_id']).first
-        if session.nil?
-          custom_error(404, "#{action}.session_id.unknown")
-        end
-        return session
-      end
-
-      def check_application(action)
-        check_presence('app_key', route: action)
-        application = Arkaan::OAuth::Application.where(key: params['app_key']).first
-        custom_error(404, "#{action}.app_key.unknown") if application.nil?
-        return application
-      end
-
-      # Adds the parsed body to the parameters, overwriting the parameters of the querystring with the values
-      # of the SON body if they have similar keys.
-      def add_body_to_params
-        if request.body.respond_to?(:rewind) && request.body.respond_to?(:read)
-          request.body.rewind 
-          parsed_body = JSON.parse(request.body.read.to_s) rescue {}
-          parsed_body.keys.each do |key|
-            params[key] = parsed_body[key]
-          end
-        end
-      end
-
-      # Gets the current route in the database from the sinatra route.
-      # @return [Arkaan::Monitoring::Route] the route declared in the services registry.
-      def parse_current_route
-        splitted = request.env['sinatra.route'].split(' ')
-        return Arkaan::Monitoring::Route.where(verb: splitted.first.downcase, path: splitted.last).first
-      end
-
-      # Halts the application and creates the returned body from the parameters and the errors config file.
-      # @param status [Integer] the HTTP status to halt the application with.
-      # @param path [String] the path in the configuration file to access the URL.
-      def custom_error(status, path)
-        route, field, error = path.split('.')
-        docs = settings.errors[route][field][error] rescue ''
-        halt status, {status: status, field: field, error: error, docs: docs}.to_json
-      end
-
-      # Halts the application with a Bad Request error affecting a field of a model.
-      # @param instance [Mongoid::Document] the document having a field in error.
-      # @param route [String] the type of action you're currently doing (e.g: 'creation')
-      def model_error(instance, route)
-        messages = instance.errors.messages
-        field = messages.keys.first
-        custom_error(400, "#{route}.#{field}.#{messages[field].first}")
-      end
-
-      # Select parameters in the params hash, by its keys.
-      # @param fields [Array<String>] the keys to select in the params hash.
-      # @return [Hash] the selected chunk of the params hash.
-      def select_params(*fields)
-        return params.select { |key, value| fields.include?(key) }
-      end
-
-      # Creates a custom error from an existing Arkaan exception class.
-      # @param exception {StandardError} the exception to transform in a usable error.
-      def handle_arkaan_exception(exception)
-        custom_error(exception.status, "#{exception.action}.#{exception.field}.#{exception.error}")
-      end
-
-      error Arkaan::Utils::Errors::BadRequest do |exception|
-        handle_arkaan_exception(exception)
-      end
-
-      error Arkaan::Utils::Errors::Forbidden do |exception|
-        handle_arkaan_exception(exception)
-      end
-
-      error Arkaan::Utils::Errors::NotFound do |exception|
-        handle_arkaan_exception(exception)
-      end
-
-      error Arkaan::Factories::Errors::GatewayNotFound do |exception|
-        handle_arkaan_exception(exception)
-      end
-
-      error StandardError do |exception|
-        custom_error(500, 'system_error.unknown_field.unknown_error')
-      end
-    end
-  end
-end