icalia-sdk-event-notification 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd944c7a944c0dcdaa380b7bc2105cb46d31d04047309e997b46eff3b773e3f1
+  data.tar.gz: 9a57249cdd95b40398fd624d9295ad8a5cacbe55d0629709dc05d93c31124b7e
+SHA512:
+  metadata.gz: 0db9bd4994ad6dafbfb7133dfb800884e95614e2f28aa55d4e766984034aabdb168349a6071ff8bae0f7cf4d407cf32cf16dbc78ee574d444cbda6c81fab90ca
+  data.tar.gz: fd3672441acd33d6aa469801f5bfc2af7355db9b360efc30018edbbf5d4c693ea39ee197b4fe5f2949f60bfa24d48f37af54326c27af54ff700712b5fbc0ffda

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at TODO: Write your email address. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in icalia-sdk-events.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Icalia::Event via Notifications
+
+Welcome to your new gem! In this directory, you'll find the files you need to be
+able to package up your Ruby library into a gem. Put your Ruby code in the file
+`lib/icalia-sdk-event-notification`. To experiment with that code, run
+`bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'icalia-sdk-event-notification'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install icalia-sdk-events
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/IcaliaLabs/icalia-sdk-ruby. This project is intended to be a
+safe, welcoming space for collaboration, and contributors are expected to adhere
+to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Icalia::Sdk::Events project’s codebases, issue
+trackers, chat rooms and mailing lists is expected to follow the
+[code of conduct](https://github.com/IcaliaLabs/icalia-sdk-ruby/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'icalia-sdk-events'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/icalia-sdk-event-notification.gemspec

@@ -0,0 +1,54 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'icalia-sdk-event-notification/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'icalia-sdk-event-notification'
+  spec.version     = Icalia::Event::NOTIFICATION_VERSION
+  spec.authors     = ['Roberto Quintanilla']
+  spec.email       = %w[vov@icalialabs.com]
+
+  spec.summary     = 'Icalia SDK for Ruby - Events via Message Broker'
+  spec.description = 'Official AWS Ruby gem for Icalia Events via Message Broker' \
+                       'This gem is part of the Icalia SDK for Ruby.'
+  spec.homepage    = 'https://github.com/IcaliaLabs/icalia-sdk-ruby'
+  spec.license     = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/IcaliaLabs/icalia-sdk-ruby'
+    spec.metadata['changelog_uri'] = 'https://github.com/IcaliaLabs/icalia-sdk-ruby'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib]
+
+  spec.add_dependency 'icalia-sdk-event-core',
+                      Icalia::Event::NOTIFICATION_VERSION
+
+  # We require mattr_reader to be able to accept a `default` value, which is
+  # only supported on Rails ActiveSupport >= 5.2.0:
+  spec.add_dependency 'activesupport', '~> 5.2', '>= 5.2.0'
+
+  spec.add_dependency 'aws-sdk-sqs', '~> 1.20'
+  spec.add_dependency 'aws-sdk-sns', '~> 1.19'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/icalia-sdk-event-notification/event_triggering_record.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Icalia::Event::EventTriggeringRecord
+#
+# Defines methods & behavior of ActiveRecord models that trigger events to the
+# Icalia Event Bus whenever something changes on it.
+#
+# The specifics on how the event is generated is left to the specifics of the
+# app.
+module Icalia::Event
+  module EventTriggeringRecord
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_reader :delayed_icalia_event_publishing, default: true
+
+      after_commit :publish_create_to_icalia_events, on: :create
+      after_commit :publish_update_to_icalia_events, on: :update
+      after_commit :publish_destroy_to_icalia_events, on: :destroy
+      
+      delegate :icalia_event_class_name,
+               :icalia_event_publisher_class,
+               :icalia_events_publisher_method,
+               :delayed_icalia_event_publishing?,
+               to: :class
+    end
+
+    module ClassMethods
+      def icalia_events_publisher_method
+        return :perform_now unless delayed_icalia_event_publishing?
+        :perform_later
+      end
+
+      def delayed_icalia_event_publishing?
+        delayed_icalia_event_publishing == true
+      end
+
+      def publish_to_icalia_events_immediately!
+        class_variable_set :@@delayed_icalia_event_publishing, false
+      end
+      
+      def publish_to_icalia_events_later!
+        class_variable_set :@@delayed_icalia_event_publishing, true
+      end
+
+      def icalia_event_publishing_enabled?
+        :publish_to_icalia_events.in? self
+          ._commit_callbacks
+          .select { |callback| callback.kind.eql?(:after) }
+          .map(&:filter)
+      end
+    
+      def icalia_event_publishing_disabled?
+        !icalia_event_publishing_enabled?
+      end
+    
+      def disable_icalia_event_publishing
+        skip_callback(:commit, :after, :publish_to_icalia_events)
+      end
+    
+      def enable_icalia_event_publishing
+        set_callback(:commit, :after, :publish_to_icalia_events)
+      end
+    
+      def without_icalia_event_publishing(&_block)
+        disable_icalia_event_publishing if icalia_event_publishing_enabled?
+        result = yield self
+        enable_icalia_event_publishing if icalia_event_publishing_disabled?
+        result
+      end
+    
+      def icalia_event_class_name
+        # The default behavior is to return the class name + 'Event':
+        "#{name}Event"
+      end
+
+      def icalia_event_publisher_class_name
+        "IcaliaEventPublishing::Publish#{icalia_event_class_name}Job"
+      end
+
+      def icalia_event_publisher_class
+        icalia_event_publisher_class_name.safe_constantize
+      end
+    end
+
+    private
+
+      def publish_to_icalia_events(action)
+        publisher_class = icalia_event_publisher_class
+        return unless publisher_class.present?
+        publisher_class.send icalia_events_publisher_method, action.to_s, self 
+      end
+
+      def publish_create_to_icalia_events
+        publish_to_icalia_events 'created'
+      end
+
+      def publish_update_to_icalia_events
+        publish_to_icalia_events 'updated'
+      end
+      
+      def publish_destroy_to_icalia_events
+        publish_to_icalia_events 'destroyed'
+      end
+  end
+end

data/lib/icalia-sdk-event-notification/notification.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Icalia::Event
+  #= Icalia::Event::Notification
+  class Notification
+    attr_reader :data,
+                :topic,
+                :event_data,
+                :included_data,
+                :metadata
+    
+    def initialize(raw_notification)
+      @data = parse_raw_notification raw_notification
+    end
+
+    def topic_arn; data.fetch :topic_arn; end
+    def topic;     @topic ||= topic_arn.split(':')[5..-1].join(':'); end
+
+    def metadata;  @metadata ||= data.dig :message, :meta; end
+    def emitter;   metadata.dig :emitter; end
+
+    def message;   data.fetch :message; end
+
+    def event_data; @event_data ||= deserialize_data(message.fetch(:data)); end
+    def action; event_data.fetch(:action, 'message'); end
+
+    def included_data
+      @included_data ||= message
+      .fetch(:included)
+      .each_with_object({}) do |data, included|
+        included[data.slice(:id, :type)] = deserialize_data(data)
+      end
+    end
+
+    def fetch_data(property_name)
+      fetched_property = fetch_attribute property_name
+      return fetched_property if fetched_property.present?
+
+      fetch_relationship property_name
+    end
+
+    delegate :parse_raw_notification, :deserialize_data, to: :class
+
+    class << self
+      delegate :decode, to: ActiveSupport::JSON, prefix: :json
+
+      def parse_raw_notification(raw_notification)
+        json_decode(raw_notification)
+          .transform_keys(&:underscore)
+          .tap { |parsed| parsed['message'] = json_decode parsed['message'] }
+          .with_indifferent_access
+      end
+  
+      def deserialize_data(data)
+        klass = data.fetch(:type).underscore.classify
+        deserializer = "Icalia::Event::Deserializable#{klass}".constantize
+        deserializer.call(data).with_indifferent_access
+      end
+    end
+
+    private
+
+    def fetch_attribute(attribute_name)
+      message.dig(:data, :attributes, attribute_name) ||
+      message.dig(:data, :attributes, attribute_name.to_s.dasherize)
+    end
+
+    def fetch_relationship(relationship_name)
+      rel = message.dig(:data, :relationships, relationship_name) ||
+            message.dig(:data, :relationships, relationship_name.to_s.dasherize)
+      return unless rel.present?
+      included_data[rel.fetch(:data)]
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/publisher.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Icalia::Event
+  class Publisher
+
+    class UnknownTopicError < StandardError
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      delegate :publish, to: :instance
+    end
+
+    attr_reader :sns_client
+
+    def initialize
+      @sns_client = Aws::SNS::Resource.new Icalia::Event.sns_client_options
+    end
+
+    def publish(topic_name, data, json_data: true)
+      raise UnknownTopicError, "Topic '#{topic_name}' does not exist" \
+        unless topic_exists?(topic_name)
+
+      topic = get_topic topic_name
+      topic.publish message: (json_data ? json_encode(data) : data)
+    end
+
+    delegate :encode, to: ActiveSupport::JSON, prefix: :json
+
+    protected
+
+    def get_topic(topic_name)
+      sns_client.topics.detect do |topic|
+        topic.arn.split(':').last == topic_name
+      end
+    end
+
+    def topic_exists?(topic_name)
+      get_topic(topic_name).present?
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/cli/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Icalia::Event::Shoryuken::CLI
+  class Base < Thor
+    no_commands do
+      def print_table(entries)
+        column_sizes = print_columns_size(entries)
+
+        entries.map do |entry|
+          puts entry.map.with_index { |e, i| print_format_column(e, column_sizes[i]) }.join
+        end
+      end
+
+      def print_columns_size(entries)
+        column_sizes = Hash.new(0)
+
+        entries.each do |entry|
+          entry.each_with_index do |e, i|
+            e = e.to_s
+            column_sizes[i] = e.size if column_sizes[i] < e.size
+          end
+        end
+
+        column_sizes
+      end
+
+      def print_format_column(column, size)
+        size_with_padding = size + 4
+        column = column.to_s.ljust(size_with_padding)
+        column
+      end
+
+      def fail_task(msg, quit = true)
+        say "[FAIL] #{msg}", :red
+        exit(1) if quit
+      end
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/cli/runner.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'aws-sdk-core'
+
+module Icalia::Event::Shoryuken::CLI
+  class Runner < Base
+    default_task :start
+
+    register Icalia::Event::Shoryuken::CLI::SQS,
+             'sqs',
+             'sqs COMMAND',
+             'SQS commands'
+
+    desc 'start', 'Starts shoryuken'
+    method_option :concurrency, aliases: '-c', type: :numeric, desc: 'Processor threads to use'
+    method_option :daemon,      aliases: '-d', type: :boolean, desc: 'Daemonize process'
+    method_option :queues,      aliases: '-q', type: :array,   desc: 'Queues to process with optional weights'
+    method_option :require,     aliases: '-r', type: :string,  desc: 'Dir or path of the workers'
+    method_option :timeout,     aliases: '-t', type: :numeric, desc: 'Hard shutdown timeout'
+    method_option :config,      aliases: '-C', type: :string,  desc: 'Path to config file'
+    method_option :config_file,                type: :string,  desc: 'Path to config file (backwards compatibility)'
+    method_option :rails,       aliases: '-R', type: :boolean, desc: 'Load Rails'
+    method_option :logfile,     aliases: '-L', type: :string,  desc: 'Path to logfile'
+    method_option :pidfile,     aliases: '-P', type: :string,  desc: 'Path to pidfile'
+    method_option :verbose,     aliases: '-v', type: :boolean, desc: 'Print more verbose output'
+    method_option :delay,       aliases: '-D', type: :numeric, desc: 'Number of seconds to pause fetching from an empty queue'
+    
+    def start
+      opts = options.to_h.symbolize_keys
+
+      say '[DEPRECATED] Please use --config instead of --config-file', :yellow if opts[:config_file]
+
+      opts[:config_file] = opts.delete(:config) if opts[:config]
+
+      # Keep compatibility with old CLI queue format
+      opts[:queues] = opts[:queues].reject(&:empty?).map { |q| q.split(',') } if opts[:queues]
+
+      fail_task "You should set a logfile if you're going to daemonize" if opts[:daemon] && opts[:logfile].nil?
+
+      Shoryuken::Runner.instance.run(opts.freeze)
+    end
+
+    desc 'version', 'Prints version'
+    def version
+      say "Shoryuken #{Shoryuken::VERSION}"
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/cli/sqs.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'date'
+
+# rubocop:disable Metrics/BlockLength
+module Icalia::Event::Shoryuken::CLI
+  class SQS < Base
+    namespace :sqs
+
+    no_commands do
+      def normalize_dump_message(message)
+        # symbolize_keys is needed for keeping it compatible with `requeue`
+        attributes = message[:attributes].symbolize_keys
+        {
+          id: message[:message_id],
+          message_body: message[:body],
+          message_attributes: message[:message_attributes],
+          message_deduplication_id: attributes[:MessageDeduplicationId],
+          message_group_id: attributes[:MessageGroupId]
+        }
+      end
+
+      def sqs
+        @_sqs ||= Aws::SQS::Client.new Icalia::Event.sqs_client_options
+      end
+
+      def find_queue_url(queue_name)
+        sqs.get_queue_url(queue_name: queue_name).queue_url
+      rescue Aws::SQS::Errors::NonExistentQueue
+        fail_task "The specified queue #{queue_name} does not exist"
+      end
+
+      def batch_delete(url, messages)
+        messages.to_a.flatten.each_slice(10) do |batch|
+          sqs.delete_message_batch(
+            queue_url: url,
+            entries: batch.map { |message| { id: message.message_id, receipt_handle: message.receipt_handle } }
+          ).failed.any? do |failure|
+            say(
+              "Could not delete #{failure.id}, code: #{failure.code}, message: #{failure.message}, sender_fault: #{failure.sender_fault}",
+              :yellow
+            )
+          end
+        end
+      end
+
+      def batch_send(url, messages, messages_per_batch = 10)
+        messages.to_a.flatten.map(&method(:normalize_dump_message)).each_slice(messages_per_batch) do |batch|
+          sqs.send_message_batch(queue_url: url, entries: batch).failed.any? do |failure|
+            say "Could not requeue #{failure.id}, code: #{failure.code}", :yellow
+          end
+        end
+      end
+
+      def find_all(url, limit)
+        count = 0
+        batch_size = limit > 10 ? 10 : limit
+
+        loop do
+          n = limit - count
+          batch_size = n if n < batch_size
+
+          messages = sqs.receive_message(
+            queue_url: url,
+            max_number_of_messages: batch_size,
+            attribute_names: ['All'],
+            message_attribute_names: ['All']
+          ).messages
+
+          messages.each { |m| yield m }
+
+          count += messages.size
+
+          break if count >= limit
+          break if messages.empty?
+        end
+
+        count
+      end
+
+      def list_and_print_queues(urls)
+        attrs = %w[QueueArn ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible LastModifiedTimestamp]
+
+        entries = urls.map { |u| sqs.get_queue_attributes(queue_url: u, attribute_names: attrs).attributes }.map do |q|
+          [
+            q['QueueArn'].split(':').last,
+            q['ApproximateNumberOfMessages'],
+            q['ApproximateNumberOfMessagesNotVisible'],
+            Time.at(q['LastModifiedTimestamp'].to_i)
+          ]
+        end
+
+        entries.unshift(['Queue', 'Messages Available', 'Messages Inflight', 'Last Modified'])
+
+        print_table(entries)
+      end
+
+      def dump_file(path, queue_name)
+        File.join(path, "#{queue_name}-#{Date.today}.jsonl")
+      end
+    end
+
+    desc 'ls [QUEUE-NAME-PREFIX]', 'Lists queues'
+    method_option :watch,    aliases: '-w', type: :boolean, desc: 'watch queues'
+    method_option :interval, aliases: '-n', type: :numeric, default: 2, desc: 'watch interval in seconds'
+    def ls(queue_name_prefix = '')
+      trap('SIGINT', 'EXIT') # expect ctrl-c from loop
+
+      urls = sqs.list_queues(queue_name_prefix: queue_name_prefix).queue_urls
+
+      loop do
+        list_and_print_queues(urls)
+
+        break unless options[:watch]
+
+        sleep options[:interval]
+        puts
+      end
+    end
+
+    desc 'dump QUEUE-NAME', 'Dumps messages from a queue into a JSON lines file'
+    method_option :number, aliases: '-n', type: :numeric, default: Float::INFINITY, desc: 'number of messages to dump'
+    method_option :path,   aliases: '-p', type: :string,  default: './',            desc: 'path to save the dump file'
+    method_option :delete, aliases: '-d', type: :boolean, default: true,            desc: 'delete from the queue'
+    def dump(queue_name)
+      path = dump_file(options[:path], queue_name)
+
+      fail_task "File #{path} already exists" if File.exist?(path)
+
+      url = find_queue_url(queue_name)
+
+      messages = []
+
+      file = nil
+
+      count = find_all(url, options[:number]) do |m|
+        file ||= File.open(path, 'w')
+
+        file.puts(JSON.dump(m.to_h))
+
+        messages << m if options[:delete]
+      end
+
+      batch_delete(url, messages) if options[:delete]
+
+      if count.zero?
+        say "Queue #{queue_name} is empty", :yellow
+      else
+        say "Dump saved in #{path} with #{count} messages", :green
+      end
+    ensure
+      file.close if file
+    end
+
+    desc 'requeue QUEUE-NAME PATH', 'Requeues messages from a dump file'
+    method_option :batch_size, aliases: '-n', type: :numeric, default: 10, desc: 'number of messages per batch to send'
+    def requeue(queue_name, path)
+      fail_task "Path #{path} not found" unless File.exist?(path)
+
+      messages = File.readlines(path).map { |line| JSON.parse(line, symbolize_names: true) }
+
+      batch_send(find_queue_url(queue_name), messages, options[:batch_size])
+
+      say "Requeued #{messages.size} messages from #{path} to #{queue_name}", :green
+    end
+
+    desc 'mv QUEUE-NAME-SOURCE QUEUE-NAME-TARGET', 'Moves messages from one queue (source) to another (target)'
+    method_option :number, aliases: '-n', type: :numeric, default: Float::INFINITY, desc: 'number of messages to move'
+    method_option :delete, aliases: '-d', type: :boolean, default: true,            desc: 'delete from the queue'
+    def mv(queue_name_source, queue_name_target)
+      url_source = find_queue_url(queue_name_source)
+      messages = []
+
+      count = find_all(url_source, options[:number]) do |m|
+        messages << m
+      end
+
+      batch_send(find_queue_url(queue_name_target), messages.map(&:to_h))
+      batch_delete(url_source, messages) if options[:delete]
+
+      if count.zero?
+        say "Queue #{queue_name_source} is empty", :yellow
+      else
+        say "Moved #{count} messages from #{queue_name_source} to #{queue_name_target}", :green
+      end
+    end
+
+    desc 'purge QUEUE-NAME', 'Deletes the messages in a queue'
+    def purge(queue_name)
+      sqs.purge_queue(queue_url: find_queue_url(queue_name))
+
+      say "Purge request sent for #{queue_name}. The message deletion process takes up to 60 seconds", :yellow
+    end
+
+    desc 'create QUEUE-NAME', 'Create a queue'
+    method_option :attributes, aliases: '-a', type: :hash, default: {}, desc: 'queue attributes'
+    def create(queue_name)
+      attributes = options[:attributes]
+      attributes['FifoQueue'] ||= 'true' if queue_name.end_with?('.fifo')
+
+      queue_url = sqs.create_queue(queue_name: queue_name, attributes: attributes).queue_url
+
+      say "Queue #{queue_name} was successfully created. Queue URL #{queue_url}", :green
+    end
+
+    desc 'delete QUEUE-NAME', 'delete a queue'
+    def delete(queue_name)
+      sqs.delete_queue(queue_url: find_queue_url(queue_name))
+
+      say "Queue #{queue_name} was successfully delete", :green
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/cli.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Icalia::Event::Shoryuken
+  module CLI
+    autoload :Base,   'icalia-sdk-event-notification/shoryuken/cli/base'
+    autoload :Runner, 'icalia-sdk-event-notification/shoryuken/cli/runner'
+    autoload :SQS,    'icalia-sdk-event-notification/shoryuken/cli/sqs'
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/worker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Icalia::Event::Shoryuken
+  class Worker
+    include Shoryuken::Worker
+    include Icalia::Event::TopicMessageProcessing
+
+    shoryuken_options queue: 'icalia_events', auto_delete: true
+
+    delegate :logger, to: Shoryuken
+
+    def perform(_sqs_msg, raw_notification)
+      notification = Icalia::Event::Notification.new raw_notification
+      
+      return unless process_notification?(notification)
+      
+      logger.info "Processing notification from topic"\
+                  " '#{notification.topic}'" #: #{notification.inspect}"
+      
+      # If there was no action (some events may not have an action!), we'll 
+      # run the `process_message` method instead:
+      action_name = notification.action || 'default'
+      send "process_#{action_name.underscore}".to_sym, notification
+    end
+
+    delegate :process_notification,
+             :process_notification?,
+             :define_noop_action_processor,
+             to: :class
+
+    class ActionProcessorPatternTest
+      attr_reader :action_name
+      
+      def initialize(method_sym)
+        if method_sym.to_s =~ /\Aprocess_(\w+)\z/
+          @action_name = $1.to_sym
+        end
+      end
+      
+      def match?; @action_name != nil; end
+    end
+
+    class << self
+      def method_missing(method_sym, *arguments, &block)
+        processor_test = ActionProcessorPatternTest.new(method_sym)
+        if processor_test.match?
+          define_noop_action_processor(method_sym, processor_test.action_name)
+          send(method_sym, *arguments)
+        else
+          super
+        end
+      end
+  
+      def define_noop_action_processor(action_processor_method, action_name)
+        define_singleton_method action_processor_method do |*args|
+          logger.info "#{name} does not know how to process #{action_name}" \
+                      " - Ignoring message"
+        end
+        delegate action_processor_method, to: :class
+      end
+
+      def process_data?(data); true; end
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken/worker_registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Icalia::Event::Shoryuken
+  class WorkerRegistry < Shoryuken::DefaultWorkerRegistry
+    def fetch_worker(queue, message)
+      worker = super
+      return worker if worker.present?
+  
+      require_jobs if empty_mappings?
+  
+      topic_name = extract_topic_name(message)
+  
+      worker_class = Icalia::Event::TopicMessageProcessing
+        .worker_mappings[topic_name]
+      
+      return worker_class.new if worker_class.present?
+    end
+  
+    protected
+  
+    delegate :extract_topic_name, :require_jobs, to: :class
+    delegate :empty_mappings?, to: Icalia::Event::TopicMessageProcessing
+  
+    def self.require_jobs
+      path = Rails.root.join('app', 'jobs', '**', '*_job.rb')
+      Dir[path].each {|file| require file }
+    end
+  
+    def self.extract_topic_name(message)
+      extract_metadata(message)['topic_arn'].split(':')[5..-1].join(':')
+    end
+  
+    def self.extract_metadata(message)
+      extract_body(message)
+        .except('Message')
+        .transform_keys(&:underscore)
+        .with_indifferent_access
+    end
+  
+    def self.extract_body(message)
+      ActiveSupport::JSON.decode message.body
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/shoryuken.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Icalia::Event
+  module Shoryuken
+    autoload :Worker, 'icalia-sdk-event-notification/shoryuken/worker'
+    autoload :WorkerRegistry, 'icalia-sdk-event-notification/shoryuken/worker_registry'
+    autoload :CLI, 'icalia-sdk-event-notification/shoryuken/cli'
+  end
+end

data/lib/icalia-sdk-event-notification/topic_message_processing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Icalia::Event
+  module TopicMessageProcessing
+    extend ActiveSupport::Concern
+
+    mattr_reader :worker_mappings, default: {}
+
+    def self.empty_mappings?
+      Icalia::Event::TopicMessageProcessing.worker_mappings.empty?
+    end
+
+    module ClassMethods
+      def process_from_topics(*topic_names)
+        topic_names.each do |topic_name|
+          Icalia::Event::TopicMessageProcessing
+            .worker_mappings[topic_name] = self
+        end
+      end
+
+      alias process_from_topic process_from_topics
+    end
+  end
+end

data/lib/icalia-sdk-event-notification/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Icalia
+  module Event
+    NOTIFICATION_VERSION = '0.1.0'
+  end
+end

data/lib/icalia-sdk-event-notification.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+
+module Icalia
+  module Events
+    autoload :Version, 'icalia-sdk-event-notification/version'
+    autoload :Publisher, 'icalia-sdk-event-notification/publisher'
+    autoload :Notification, 'icalia-sdk-event-notification/notification'
+    
+    autoload :Shoryuken, 'icalia-sdk-event-notification/shoryuken'
+    
+    autoload :EventTriggeringRecord,
+             'icalia-sdk-event-notification/event_triggering_record'
+    
+    autoload :TopicMessageProcessing,
+             'icalia-sdk-event-notification/topic_message_processing'
+
+    def self.generic_aws_client_options
+      {
+        region: ENV.fetch('AWS_REGION', 'us-west-2'),
+        access_key_id: ENV.fetch('AWS_ACCESS_KEY_ID'),
+        secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY')
+      }
+    end
+
+    def self.sqs_client_options
+      options = Icalia::Event.generic_aws_client_options
+      return options if ENV['AWS_SQS_ENDPOINT'].blank?
+      
+      options.merge endpoint: ENV['AWS_SQS_ENDPOINT'], verify_checksums: false
+    end
+
+    def self.sns_client_options
+      options = Icalia::Event.generic_aws_client_options
+      return options if ENV['AWS_SNS_ENDPOINT'].blank?
+      
+      options.merge endpoint: ENV['AWS_SQS_ENDPOINT']
+    end
+
+    mattr_reader :deferred_publishing, default: true
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: icalia-sdk-event-notification
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roberto Quintanilla
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: icalia-sdk-event-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sqs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sns
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Official AWS Ruby gem for Icalia Events via Message BrokerThis gem is
+  part of the Icalia SDK for Ruby.
+email:
+- vov@icalialabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- icalia-sdk-event-notification.gemspec
+- lib/.DS_Store
+- lib/icalia-sdk-event-notification.rb
+- lib/icalia-sdk-event-notification/event_triggering_record.rb
+- lib/icalia-sdk-event-notification/notification.rb
+- lib/icalia-sdk-event-notification/publisher.rb
+- lib/icalia-sdk-event-notification/shoryuken.rb
+- lib/icalia-sdk-event-notification/shoryuken/cli.rb
+- lib/icalia-sdk-event-notification/shoryuken/cli/base.rb
+- lib/icalia-sdk-event-notification/shoryuken/cli/runner.rb
+- lib/icalia-sdk-event-notification/shoryuken/cli/sqs.rb
+- lib/icalia-sdk-event-notification/shoryuken/worker.rb
+- lib/icalia-sdk-event-notification/shoryuken/worker_registry.rb
+- lib/icalia-sdk-event-notification/topic_message_processing.rb
+- lib/icalia-sdk-event-notification/version.rb
+homepage: https://github.com/IcaliaLabs/icalia-sdk-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/IcaliaLabs/icalia-sdk-ruby
+  source_code_uri: https://github.com/IcaliaLabs/icalia-sdk-ruby
+  changelog_uri: https://github.com/IcaliaLabs/icalia-sdk-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Icalia SDK for Ruby - Events via Message Broker
+test_files: []