active_spy 1.4.4 → 2.0.0.pre1

data/VERSION

@@ -1 +0,0 @@
-1.4.4

data/app/controllers/active_spy/notifications_controller.rb

@@ -1,71 +0,0 @@
-class UnsupportedORM < RuntimeError
-end
-
-module ActiveSpy
-  # Controller to handle notifications request coming from an event-runner
-  # instance.
-  #
-  class NotificationsController < ActionController::Base
-    def handle
-      request.format = 'application/json'
-      hooks = ActiveSpy::Rails::HookList.hooks
-      result = nil
-      hooks.each do |hook|
-        if hook['post_class'].downcase == params['class']
-           handle_result(hook, params) and return
-        end
-      end
-      render nothing: true, status: :not_found
-    end
-
-    def handle_result(hook, params)
-      ::Rails.logger.warn("[EVENT][#{hook['post_class']}] Event with result: #{params}")
-      result = get_result(hook, params)
-      ::Rails.logger.warn("[EVENT][#{hook['post_class']}] Listener result: #{result}")
-      if result.is_a? Array
-        handle_array_result(hook, result, params)
-      elsif is_a_model?(result)
-        handle_model_result(hook, result, params)
-      else
-        render nothing: true
-      end
-    end
-
-    def is_a_model?(something)
-      if defined?(ActiveRecord)
-        something.is_a? ActiveRecord::Base
-      elsif defined?(Mongoid)
-        something.class.included_modules.include? Mongoid::Document
-      else
-        raise UnsupportedORM
-      end
-    end
-
-    def get_result(hook, params)
-      listener = "#{hook['post_class']}Listener".constantize
-      result = listener.new.handle(params['event'])
-    end
-
-    def handle_model_result(hook, result, params)
-      if result.errors.present?
-        ::Rails.logger.warn("[EVENT][#{hook['post_class']}] Result errors: #{result.errors.full_messages}")
-        render json: result.errors, status: :unprocessable_entity
-      else
-        render nothing: true
-      end
-    end
-
-    def handle_array_result(hook, result, params)
-      model_with_errors = result.select { |m| m.errors.present? }
-      if model_with_errors.any?
-        ::Rails.logger.warn("[EVENT][#{hook['post_class']}] Error receiving event #{params}")
-        model_with_errors.each do |model|
-          ::Rails.logger.warn("[EVENT][#{hook['post_class']}] #{model} errors: #{model.errors.full_messages}")
-        end
-        render nothing: true, status: :internal_server_error
-      else
-        render nothing: true
-      end
-    end
-  end
-end

data/lib/active_spy/base.rb

@@ -1,9 +0,0 @@
-module ActiveSpy
-  # Default template for callbacks handlers.
-  #
-  class Base
-    def initialize(object)
-      @object = object
-    end
-  end
-end

data/lib/active_spy/configuration.rb

@@ -1,106 +0,0 @@
-module ActiveSpy
-  # Defines a class to hold the configuration used to send events.
-  #
-  class Configuration
-    class << self
-      # Set the application host
-      #
-      # @param [String] host to set
-      #
-      # @return [String] the host set
-      def host(host = nil)
-        @host = host unless host.nil?
-        @host
-      end
-
-      # Set the application port
-      #
-      # @param [String] port to set
-      #
-      # @return [String] the port set
-      def port(port = nil)
-        @port = port unless port.nil?
-        @port
-      end
-
-      # Set the application name
-      #
-      # @param [String] name to set
-      #
-      # @return [String] the name set
-      def name(name = nil)
-        @name = name unless name.nil?
-        @name
-      end
-
-      # Set the default event-runner host
-      #
-      # @param [String] host to set
-      #
-      # @return [String] the host set
-      def event_host(host = nil)
-        @event_host = host unless host.nil?
-        @event_host
-      end
-
-      # Set the default event-tunner verify_ssl mode
-      #
-      # @param [String] host to set
-      #
-      # @return [String] the host set
-      def event_verify_ssl(event_verify_ssl = nil)
-        @event_verify_ssl = event_verify_ssl unless event_verify_ssl.nil?
-        @event_verify_ssl
-      end
-
-      # Set if the gem is in development mode or not.
-      #
-      # @param [Boolean] development moded state to set
-      #
-      # @return [Boolean] development moded state to set
-      def development_mode(mode = nil, options = nil)
-        unless mode.nil?
-          @development_mode = mode
-          @skip_validations = options[:skip_validations] if options.present?
-        end
-        @development_mode
-      end
-
-      # Simple reader for +skip_validations+ attribute.
-      #
-      def skip_validations
-        @skip_validations
-      end
-
-      # Imperative method to set development mode.
-      #
-      def development_mode!
-        @development_mode = true
-      end
-
-      # Set the default event-runner port
-      #
-      # @param [String] port to set
-      #
-      # @return [String] the port set
-      def event_port(port = nil)
-        @event_port = port unless port.nil?
-        @event_port
-      end
-
-      # See how are the settings
-      #
-      # @return [Hash] actual settings
-      def settings
-        { name: @name, hostname: @host, port: @port }
-      end
-
-      # See how are the event settings
-      #
-      # @return [Hash] actual event settings
-      def event_settings
-        { host: @event_host, port: @event_port, verify_ssl: @event_verify_ssl }
-      end
-    end
-  end
-end

data/lib/active_spy/rails/base.rb

@@ -1,140 +0,0 @@
-require 'rest-client'
-require 'singleton'
-require 'json'
-
-module ActiveSpy
-  # Module to hold Rails specific classes and helpers.
-  #
-  module Rails
-    # Default template for callbacks handlers.
-    #
-    class Base
-      def initialize(object)
-        @object = object
-        inject_is_new_method(@object)
-        @object.is_new = true if @object.new_record?
-      end
-
-      # Overriding to avoid sending the object to server 2 times (in both
-      # before and after callabcks).
-      #
-      def respond_to?(method)
-        method.include?('after_')
-      end
-
-      # Inject an attribute in the +object+, called +is_new?+ and a setter
-      # for it.
-      #
-      def inject_is_new_method(object)
-        object.instance_eval do
-          def is_new=(value)
-            @is_new = value
-          end
-
-          def is_new?
-            @is_new
-          end
-        end
-      end
-
-      # Handles the generic +save+. Determines which rail action was done,
-      # +create+ or +update+ and call the right callback.
-      #
-      def after_save
-        action = get_action('save')
-        send("after_#{action}")
-      end
-
-      # Handles a +create+ callback, prepare and send the request to the event-runner.
-      #
-      def after_create
-        request_params = get_request_params('create')
-        prepare_request(request_params)
-        send_event_request unless ActiveSpy::Configuration.development_mode
-      end
-
-      # Handles an +update+ callback, prepare and send the request to the event-runner.
-      #
-      def after_update
-        request_params = get_request_params('update')
-        prepare_request(request_params)
-        send_event_request unless ActiveSpy::Configuration.development_mode
-      end
-
-      # Handles an +destroy+ callback, prepare and send the request to the event-runner.
-      #
-      def after_destroy
-        request_params = get_request_params('destroy')
-        prepare_request(request_params)
-        send_event_request unless ActiveSpy::Configuration.development_mode
-      end
-
-      # Prepare a request with +request_params+, validates the request and
-      # remove the injected +is_mew_method+, because it's not needed anymore.
-      #
-      def prepare_request(request_params)
-        @event_json = { event: request_params }.to_json
-        ActiveSpy::Rails::Validation::Event.new(@event_json).validate! unless ActiveSpy::Configuration.skip_validations
-        remove_is_new_method(@object)
-      end
-
-      # Sends the event request to the configured event-runner instance.
-      #
-      def send_event_request
-        response    = nil
-        host        = ActiveSpy::Configuration.event_host
-        port        = ActiveSpy::Configuration.event_port
-        verify_ssl  = ActiveSpy::Configuration.event_verify_ssl
-        url         = "#{host}:#{port}/events"
-
-        params = { headers: { content_type: :json }, method: :post, url: url, payload: @event_json }
-        params[:verify_ssl] = verify_ssl if verify_ssl
-
-        begin
-          response = RestClient::Request.execute(params)
-        rescue => e
-          ::Rails.logger.info(e.response)
-        end
-        if response && defined?(Rails) && !ActiveSpy::Configuration.development_mode
-          ::Rails.logger.info('[SPY] Event sent to event-runner.')
-          ::Rails.logger.info("[SPY] Event-runner response code: #{response.code}")
-          ::Rails.logger.info("[SPY] Event-runner response: #{response.body}")
-        end
-      end
-
-      # Get the event request params for a given +method+.
-      #
-      def get_request_params(action)
-        # real_method = method.to_s.split('_').last
-        # action = get_action(real_method)
-        {
-          type:     @object.class.name,
-          actor:    @object.instance_variable_get('@actor'),
-          realm:    @object.instance_variable_get('@realm'),
-          payload:  @object.payload_for(action),
-          action:   action
-        }
-      end
-
-      # Remove a previously added +is_new+ attribute from a given object.
-      #
-      def remove_is_new_method(object)
-        object.instance_eval do
-          undef :is_new=
-          undef :is_new?
-          instance_variable_set(:@is_new, nil)
-        end
-      end
-
-      # Returns the correct action for the method called in the model.
-      #
-      def get_action(real_method)
-        if real_method == 'save'
-          return 'create' if @object.is_new?
-          return 'update'
-        end
-        'destroy'
-      end
-    end
-  end
-end

data/lib/active_spy/rails/engine.rb

@@ -1,7 +0,0 @@
-module ActiveSpy
-  # Class responsible for the controller and routes integration with Rails
-  #
-  class Engine < ::Rails::Engine
-    isolate_namespace ActiveSpy
-  end
-end

data/lib/active_spy/rails/hook_list.rb

@@ -1,141 +0,0 @@
-module ActiveSpy
-  module Rails
-    # Class used to hold all the events hook's paths and later sync
-    # them with an event runner instance.
-    #
-    class HookList
-      include Singleton
-
-      # Simple attribute reader for hooks
-      #
-      attr_reader :hooks
-
-      # Initialize an empty hook list
-      #
-      def initialize
-        host = ActiveSpy::Configuration.event_host
-        port = ActiveSpy::Configuration.event_port
-        name = ActiveSpy::Configuration.name.downcase.gsub(' ', '-').strip
-
-        @verify_ssl       = ActiveSpy::Configuration.event_verify_ssl
-        @base_service_url = "#{host}:#{port}/services/#{name}"
-        @hooks            = []
-      end
-
-      # Proxy all methods called in the {ActiveSpy::Hook} to
-      # {ActiveSpy::Hook} instance. Just a syntax sugar.
-      #
-      def self.method_missing(method, *args, &block)
-        instance.send(method, *args, &block)
-      end
-
-      # Clear the hook list.
-      #
-      def clear
-        @hooks = []
-      end
-
-      # forward {<<} method to the hook list.
-      #
-      def <<(other)
-        @hooks << other
-      end
-
-      # Register in event runner all the hooks defined in the list. If some of
-      # them already exists, they will be excluded and readded.
-      #
-      def register
-        @hooks = @hooks.map(&:to_hook).flatten
-        old_hooks = get_old_hooks
-        hooks_to_delete = get_hooks_to_delete(old_hooks)
-        hooks_to_add = get_hooks_to_add(old_hooks)
-        delete_hooks(hooks_to_delete) if hooks_to_delete.any?
-        add_hooks(hooks_to_add) unless hooks_to_add.empty?
-      end
-
-      # Get the old hooks list for this service from the event-runner
-      #
-      def get_old_hooks
-        request = if @verify_ssl
-          RestClient::Request.execute(method: :get, url: @base_service_url, verify_ssl: @verify_ssl)
-        else
-          RestClient.get(@base_service_url)
-        end
-
-        JSON.load(request)['hooks']
-      end
-
-      # Select from old hooks those that should be deleted from event runner.
-      #
-      def get_hooks_to_delete(old_hooks)
-        hooks_to_delete = []
-        old_hooks.each do |old_hook|
-          found = false
-          @hooks.each do |hook|
-            if hook['class'] == old_hook['class'] && old_hook['active']
-              found = true
-              break
-            end
-          end
-          next if found
-          hooks_to_delete << old_hook
-        end
-        hooks_to_delete
-      end
-
-      # Select from the hooks defined in the app those that should be created
-      # in the event runner.
-      #
-      def get_hooks_to_add(old_hooks)
-        hooks_to_add = []
-        @hooks.each do |hook|
-          found = false
-          old_hooks.each do |old_hook|
-            if hook['class'] == old_hook['class'] && old_hook['active']
-              found = true
-              break
-            end
-          end
-          next if found
-          hooks_to_add << hook
-        end
-        hooks_to_add
-      end
-
-      # Properly delete the +hooks_to_delete+ in the event runner.
-      #
-      def delete_hooks(hooks_to_delete)
-        hooks_to_delete.each do |hook|
-          url = "#{@base_service_url}/hooks/#{hook['id']}"
-          if @verify_ssl
-            RestClient::Request.execute(method: :delete, url: url, verify_ssl: @verify_ssl)
-          else
-            RestClient.delete url
-          end
-        end
-      end
-
-      # # Properly creates the +hooks_to_add+ in the event runner.
-      #
-      def add_hooks(hooks_to_add)
-        url = "#{@base_service_url}/hooks"
-
-        hooks_to_add.each do |hook|
-          hook = {
-            'hook' => {
-              'class' => hook['class'],
-              'post_path' => ActiveSpy::Engine.routes.url_helpers.notifications_path(hook['post_class'].downcase),
-            }
-          }
-
-          if @verify_ssl
-            RestClient::Request.execute(method: :post, url: url, payload: hook.to_json,
-              headers: { content_type: :json }, verify_ssl: @verify_ssl)
-          else
-            RestClient.post url, hook.to_json, content_type: :json
-          end
-        end
-      end
-    end
-  end
-end