microbunny 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6004da088017f240efedf6234513db4f7e3a3b8
+  data.tar.gz: 2f97d08358e659eac313cccb0ad789ff5e19ab44
+SHA512:
+  metadata.gz: 7eb1fd169b8b4020c2c32058fa2214f2d4e7f3ccf85c48fdc3ccc092b68e366965c117050cae1e4d589578da71724f4a526846563743d488938379bacbca8f52
+  data.tar.gz: 188db2b1c7338f611915dcaacb62edad977a32a6ffe87ec49bb6eb507b9164564b1802afa7bd7564cb6879534b36649cfa75d23ea9e7ef91d94327247e219114

data/lib/microbunny/connection.rb

@@ -0,0 +1,21 @@
+module MicroBunny
+  class Connection
+    def initialize(host:, vhost: nil, username: 'guest', password: 'guest')
+      @conn = Bunny.new(
+        host: host,
+        vhost: vhost,
+        username: username,
+        password: password
+      )
+      conn.start
+    end
+
+    def channel
+      @channel ||= conn.create_channel
+    end
+
+    private
+    attr_reader :conn
+  end
+end
+

data/lib/microbunny/event.rb

@@ -0,0 +1,49 @@
+require 'json'
+require_relative './record'
+require_relative './payload'
+
+module MicroBunny
+  class Event
+    def self.exchange(name)
+      define_method(:exchange) do
+        name.to_sym
+      end
+    end
+
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def publish(message, record_id = nil)
+      x = channel.topic(self.exchange)
+      payload = build_payload(name, message)
+
+      if record_id
+        record = Record.new(record_id)
+        payload.record = record.id
+        x.publish(payload.serialize, routing_key: record.routing_key_for(self))
+      else
+        x.publish(payload.serialize, routing_key: name)
+      end
+    end
+
+    def name
+      self.class.name.gsub(/Event$/, '')
+    end
+
+    private
+
+    attr_reader :channel
+
+    def build_payload(name, message)
+      Payload.new(event: name, message: message)
+    end
+
+    def serialize(payload)
+      payload.to_json
+    end
+  end
+end
+
+
+

data/lib/microbunny/event_lookup.rb

@@ -0,0 +1,26 @@
+module MicroBunny
+  class EventLookup
+    def initialize(name)
+      @name = name.is_a?(Symbol) ? camelize(name.to_s) : name
+    end
+
+    def event
+      constantize(name + "Event")
+    end
+
+    def consumer
+      constantize(name + "Consumer")
+    end
+
+    private
+    attr_reader :name
+
+    def camelize(string)
+      string.split('_').map(&:capitalize).join
+    end
+
+    def constantize(string)
+      Object.const_get(string)
+    end
+  end
+end

data/lib/microbunny/event_trigger.rb

@@ -0,0 +1,25 @@
+module MicroBunny
+  class EventTrigger
+    def initialize(channel, name, lookup = EventLookup)
+      @event = lookup.new(name).event.new(channel)
+    end
+
+    def with(payload)
+      @payload = payload
+      self
+    end
+
+    def for(record)
+      @record = record
+      self
+    end
+
+    def broadcast
+      record ? @event.trigger(payload, record) : @event.trigger(payload)
+    end
+
+    private
+    attr_reader :channel, :event, :payload, :record
+  end
+end
+

data/lib/microbunny/payload.rb

@@ -0,0 +1,22 @@
+require 'json'
+
+module MicroBunny
+  class Payload
+    attr_accessor :event, :message, :record
+
+    def self.deserialize(json)
+      new JSON.parse(json, symbolize_names: true)
+    end
+
+    def initialize(event:, message:, record: nil)
+      @event = event
+      @message = message
+      @record = record
+    end
+
+    def serialize
+      {event: event, message: message, record: record}.to_json
+    end
+  end
+end
+

data/lib/microbunny/record.rb

@@ -0,0 +1,59 @@
+module MicroBunny
+  class Record
+    attr_reader :label
+
+    def initialize(record, settings = MicroBunny.settings)
+      @record = record
+      @label = extract_label(record)
+      @settings = settings
+    end
+
+    def id
+      if string?
+        record
+      elsif active_record?
+        record.id
+      else
+        raise_invalid_record
+      end
+    end
+
+    def routing_key_matcher
+      "*.#{label}"
+    end
+
+    def routing_key_for(event)
+      "#{event.name}.#{label}" 
+    end
+
+    def address
+      "#{settings.consumer_app}-#{label}"
+    end
+
+    private
+
+    attr_reader :record, :settings
+
+    def extract_label(record)
+      return record if string?
+      return activerecord_label if active_record?
+      raise_invalid_record
+    end
+
+    def string?
+      record.is_a? String
+    end
+
+    def active_record?
+      record.is_a? ActiveRecord::Base
+    end
+
+    def activerecord_label
+      "#{record.class.name.downcase}-#{record.id}"
+    end
+
+    def raise_invalid_record
+      raise "A record must be either a String or an ActiveRecord object"
+    end
+  end
+end

data/lib/microbunny/settings.rb

@@ -0,0 +1,9 @@
+module MicroBunny
+  class Settings
+    attr_accessor :host, :vhost, :username, :password, :consumer_app
+
+    def complete?
+      @complete ||= connection && consumer_app
+    end
+  end
+end

data/lib/microbunny/subscriber.rb

@@ -0,0 +1,37 @@
+module MicroBunny
+  class Subscriber
+    def initialize(channel, exchange, callback)
+      @channel = channel
+      @exchange = exchange
+      @callback = callback
+      @settings = settings
+    end
+
+    def topic(topic)
+      queue = find_queue(topic)
+      queue.bind(exchange, routing_key: "*")
+      queue.subscribe { |_info, _meta, payload| callback.call(payload) }
+    end
+
+    def records(records)
+      records.each do |record|
+        queue = find_queue_for_record(record)
+        queue.bind(exchange, routing_key: record.routing_key_matcher)
+        queue.subscribe { |_info, _meta, payload| callback.call(payload) }
+      end
+    end
+
+    private
+
+    attr_reader :channel, :exchange, :callback, :settings
+
+    def find_queue(name)
+      channel.queue(name)
+    end
+
+    def find_queue_for_record(record)
+      find_queue(record.address)
+    end
+  end
+end
+

data/lib/microbunny/subscriptions.rb

@@ -0,0 +1,33 @@
+require_relative './subscriber'
+
+module MicroBunny
+  class Subscriptions
+    def initialize(channel, topics, records, &block)
+      @channel = channel
+      @topics = topics
+      @records = records
+      @callback = block
+    end
+
+    def create
+      all(topics).each do |topic|
+        exchange = create_exchange(topic)
+        sub = Subscriber.new(channel, exchange, callback)
+        records.empty? ? sub.topic(topic) : sub.records(records)
+      end
+    end
+
+    private
+
+    attr_reader :channel, :topics, :records, :callback
+
+    def all(topics)
+      Array(topics).flatten.map(&:to_sym)
+    end
+
+    def create_exchange(topic)
+      channel.topic(topic)
+    end
+  end
+end
+

data/lib/microbunny.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'bunny'
+
+require_relative 'microbunny/settings'
+require_relative 'microbunny/connection'
+require_relative 'microbunny/record'
+require_relative 'microbunny/subscriptions'
+require_relative 'microbunny/event_lookup'
+require_relative 'microbunny/event_trigger'
+require_relative 'microbunny/event'
+require_relative 'microbunny/payload'
+
+module MicroBunny
+  class << self
+    attr_accessor :settings, :channel
+
+    def configure
+      self.settings ||= Settings.new
+      yield(settings)
+    end
+
+    def start
+      self.channel = Connection.new(
+        host: self.settings.host,
+        vhost: self.settings.vhost,
+        username: self.settings.username,
+        password: self.settings.password
+      ).channel
+    end
+   
+    def subscribe(topics, record_ids = [])
+      raise_bad_start unless self.channel
+
+      records = record_ids.map(&Record.method(:new))
+      subs = Subscriptions.new(self.channel, topics, records) do |payload|
+        handle(payload) 
+      end
+
+      subs.create
+    end
+
+    def event(name)
+      EventTrigger.new(channel, name)
+    end
+
+    private
+
+    def handle(json)
+      payload = Payload.deserialize(json) 
+      consumer = EventLookup.new(payload.event).consumer.new
+
+      if payload.record
+        consumer.process(payload.message, payload.record)
+      else
+        consumer.process(payload.message)
+      end
+    end
+   
+    def raise_bad_start
+      raise "Must call MicroBunny.start before you can subscribe" 
+    end
+  end
+end
+

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: microbunny
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Pierre Lebrun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: |2
+      MicroBunny is an small opinionated RabbitMQ framework built on top of bunny that
+      implements a routing scheme and client API optimized to help you build asynchronous,
+      event-based communication between web services (such as microservices). If you're
+      interesting in building resilient, loosely coupled and self contained services, then
+      this framework may be for you.
+email:
+- plebrun@on-site.com
+- anthonylebrun@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/microbunny.rb
+- lib/microbunny/connection.rb
+- lib/microbunny/event.rb
+- lib/microbunny/event_lookup.rb
+- lib/microbunny/event_trigger.rb
+- lib/microbunny/payload.rb
+- lib/microbunny/record.rb
+- lib/microbunny/settings.rb
+- lib/microbunny/subscriber.rb
+- lib/microbunny/subscriptions.rb
+homepage: https://github.com/on-site/microbunny
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A RabbitMQ framework for asynchronous communication between services
+test_files: []