dakwak 1.0.3 → 1.6.5

data/lib/dakwak/messaging/message.rb

@@ -0,0 +1,68 @@
+module Dakwak
+
+  # Messages are the AMQP entities exchanged by communicators. All messages
+  # are sent through queues bound to certain channels. To exchange messages,
+  # see Dakwak::Communicator.
+  #
+  # Messages contain a payload (which can be empty) and might contain the following properties:
+  #
+  # * meta.content_type
+  # * meta.content_encoding
+  # * meta.priority
+  # * meta.type
+  # * meta.delivery_mode
+  # * meta.app_id
+  # * meta.message_id
+  # * meta.user_id
+  # * meta.correlation_id
+  # * meta.headers
+  #
+  # For a full reference, consult with the amqp-client Ruby gem documentation here:
+  # http://rdoc.info/github/ruby-amqp/amqp/master/frames
+  #
+  # It is also helpful to review the supported message properties by libdakwak at:
+  # https://github.com/dakwak/libdakwak/blob/master/include/dakwak/messaging/message.hpp
+  #
+  # *Warning*:
+  # When a property was not set by the sender, it evaluates to nil and NOT to an empty
+  # string or so.
+  class Message
+    attr_reader :payload, :meta, :queue
+
+    # Creates a new message with the given payload and meta attributes.
+    def initialize(payload, meta = {}, queue = "")
+      @payload, @meta, @queue = payload, meta, queue
+      @meta[:headers] ||= {} if @meta.class == Hash
+    end
+
+    # If the message_id property was set by the sender, then a reply is expected.
+    #
+    # The address to send back to will be specified in this message's meta.reply_to,
+    # and the meta.message_id should be used as the reply's meta.correlation_id
+    # so the recepient can route the reply.
+    def expects_reply?()
+      !@meta.message_id.nil? && !@meta.headers["queue_name"].nil?
+    end
+
+    # Builds a message with the proper headers and attributes to mark it
+    # as a reply to the current one.
+    #
+    # You can use the returned message, set its payload if needed, to publish the reply.
+    def prepare_reply(payload = "")
+      Message.new(payload, { :reply_to => @meta.app_id, :correlation_id => @meta.message_id },
+        @meta.headers["queue_name"])
+    end
+
+    def to_s
+      "Sender: '#{@meta.app_id}@#{(@meta.headers || {})["queue_name"]}' -- #{@payload[0..30]}"
+    end
+
+    def dump
+      str = ""
+      @meta.attributes.each_pair { |k,v| str << "#{k} => #{v}\n" }
+      str
+    end
+
+  end
+
+end

data/lib/dakwak/messaging/private_channel.rb

@@ -0,0 +1,143 @@
+require 'dakwak/logger'
+
+module Dakwak
+
+  # Channels bind a number of queues which are consumed for messages sent by communicators.
+  #
+  # Dakwak::Communicator instances can _subscribe_ to channel queues to be notified
+  # of messages received, and can publish messages through channels directly.
+  #
+  # *Note*:
+  # Channels should not be managed directly, see Dakwak::Station for more info.
+  #
+  # *Note*:
+  # A channel is internally bound to an AMQP exchange entity.
+  class PrivateChannel
+    include Logger
+
+    attr_reader :session, :channel, :exchange
+
+    def opened?
+      @session && @session.connected?
+    end
+
+    # Initiates connection with the AMQP broker using connection info
+    # stored in the Dakwak::Station and binds to a direct exchange
+    # identified by the name of this channel.
+    #
+    # Params:
+    # &on_open::
+    #  A proc that will be called if and when the connection
+    #  with the broker succeeds and the exchange is bound.
+    #
+    # *Note*:
+    # This is an asynchronous method.
+    def open(&on_open)
+      if opened?
+        on_open.call(self) if on_open
+        return
+      end
+
+      AMQP.connect(Station.instance.connection_options) do |session|
+        @session = session
+        AMQP::Channel.new(@session, :auto_recovery => true) do |channel|
+          @channel  = channel
+          @exchange = @channel.default_exchange
+          on_open.call(self) if on_open
+        end
+      end
+    end
+
+    # Terminates the connection with the AMQP broker and destroys
+    # all queue consumers.
+    #
+    # Attempting to close an already closed channel will log a warning
+    # and reject the request. However, if a block was passed, it will
+    # still be called.
+    #
+    # *Note*:
+    # This is an asynchronous method.
+    def close(&on_close)
+      unless opened?
+        log_warn "Attempting to close a closed channel."
+        on_close.call(self) if on_close
+        return nil
+      end
+
+      EventMachine.next_tick do
+        @session.close {
+          @queue = nil
+          @session = nil
+
+          on_close.call(self) if on_close
+        }
+      end
+
+      nil
+    end
+
+    def name()
+      @queue.name
+    end
+
+    # Binds the specified queue and consumes any messages routed to it.
+    #
+    # *Note*:
+    # There's little point in consuming a queue with no subscribed Dakwak::Communicator
+    # instances to it. To pull messages from a queue, use Communicator::subscribe.
+    #
+    # Params:
+    # routing_key::
+    #  The AMQP routing key to use when binding the new queue to the exchange.
+    # opts::
+    # - :exclusive
+    #   The queue consumption will be exclusive to this consumer.
+    # - :nowait
+    #   Does not wait for the broker to reply. If a binding error
+    #   occurs, a Channel exception will be thrown.
+    def consume(comm, opts = {})
+      return if consuming?
+
+      @comlink = comm
+
+      # assign some defaults
+      opts = {
+        exclusive: true,
+        durable: false,
+        passive: false,
+        auto_delete: true
+      }.merge(opts)
+
+      @channel.queue("", opts) do |queue, declare_ok|
+        # TODO: handle declaration failure
+
+        @queue = queue
+
+        yield if block_given?
+
+        # log_info "Consuming #{@queue.name}"
+        @queue.subscribe { |meta, payload|
+          msg = Message.new(payload, meta)
+          # log_info "Dispatching message #{msg}"
+          @comlink.on_message_received(msg)
+        }
+      end
+    end
+
+    # Is the queue being consumed?
+    def consuming?
+      return !@queue.nil?
+    end
+
+    # Creates a new channel with name as the AMQP exchange name. Do not create
+    # channel objects directly, use Dakwak::Station instead.
+    def initialize()
+      logging_context("PrivateChannel")
+
+      @channel, @exchange, @queue, @comlink = nil, nil, nil, nil
+      super()
+    end
+
+    private
+  end
+end

data/lib/dakwak/messaging/station.rb

@@ -0,0 +1,140 @@
+require 'dakwak/logger'
+require 'dakwak/configurator'
+require 'dakwak/messaging/channel'
+
+module Dakwak
+
+  # The station is the interface for opening and closing communication channels.
+  class Station
+    include Logger
+
+    class << self
+      def instance
+        Dakwak.station
+      end
+    end
+
+    attr_reader :channels
+
+    # Opens a channel identified by 'name' if it's not already open.
+    #
+    # This method is asynchronous.
+    #
+    # Aliases: get_channel
+    def open_channel(name, opts = {}, &callback) # :yields: channel
+
+      if shutting_down?
+        log_warn "Station is shutting down, channels will not be opened."
+        return nil
+      end
+
+      if @channels[name]
+        callback.call(@channels[name]) if callback
+        return @channels[name]
+      end
+
+      c = Channel.new(name)
+      @channels[name] = c
+      c.open(opts) { |c|
+        state(:active)
+
+        log_debug "Channel #{c.name} is now open"
+        callback.call(c) if callback
+      }
+
+      return c
+    end
+
+    alias :get_channel :open_channel
+
+    # Turns off the station and all open channels. A callback must be provided
+    # that will be called when the station is shut down.
+    def shutdown(&callback)
+      raise RuntimeError.new "Station::shutdown() must be called with a callback block" unless callback
+
+      if inactive?
+        log_warn "Rejecting shutdown request; the station is currently inactive."
+        callback.call
+        return nil
+      end
+
+      if shutting_down?
+        log_warn "Rejecting shutdown request; the station is already shutting down!"
+        callback.call
+        return nil
+      end
+
+      state(:shutting_down)
+
+      # register the callback
+      @on_shutdown = callback
+
+      log_info "Closing #{@channels.size} open channels..."
+
+      channels_closed = 0
+      @channels.each_pair { |name, c|
+        c.close {
+          channels_closed += 1
+          if channels_closed == @channels.size then
+            state(:inactive)
+
+            log_info "All channels are cleanly closed. Shutdown complete."
+            @on_shutdown.call
+          end
+        }
+      }
+    end
+
+    # The station is active if it has any channels currently open.
+    def active?
+      @state == :active
+    end
+
+    # The station is inactive if there are no open channels.
+    def inactive?
+      @state == :inactive
+    end
+
+    # When shutting down, it is not permitted to attempt to open any channels.
+    def shutting_down?
+      @state == :shutting_down
+    end
+
+    def connection_options()
+      @config
+    end
+
+    def set_option(k, v)
+      @config[k.to_sym] = v
+    end
+
+    def initialize
+      logging_context( "Station" )
+
+      @channels = {}
+      @config = {
+        :host      => "127.0.0.1",
+        :port      => 5672,
+        :user      => "guest",
+        :pass      => "guest",
+        :vhost     => "/",
+        :ssl       => false,
+        :frame_max => 131072
+      }
+
+      state(:inactive)
+
+      Configurator.subscribe("Station", self)
+
+      # log_info "engaged"
+
+      super()
+    end
+
+    private
+
+    def state(in_state)
+      @state = in_state
+    end
+  end
+end

data/lib/dakwak/mongo_adapter.rb

@@ -0,0 +1,141 @@
+gem 'mongo'
+
+require 'mongo'
+
+module Dakwak
+  class MongoAdapter < Configurable
+    include Logger
+
+    attr_reader :dba, :dbh
+
+    def initialize(id = "MongoDB")
+      logging_context(id)
+      @cfg = { host: "localhost", port: 27017, db: "test" }
+      Configurator.subscribe(id, self)
+    end
+
+    def connect()
+      rescue_connection_failure do
+        if @cfg[:mode] == "single" then
+          conn_info = "#{@cfg[:single][:host]}:#{@cfg[:single][:port]}"
+          log_info "Connecting to MongoDB in Single mode to #{conn_info}"
+          @dba = Mongo::Client.new([@cfg[:single][:host]+":"+@cfg[:single][:port].to_s], ssl: @cfg[:ssl][:enable], ssl_cert: @cfg[:ssl][:ssl_cert], ssl_key: @cfg[:ssl][:ssl_key], ssl_verify: @cfg[:ssl][:ssl_verify], connect: :direct, :database => @cfg[:database])
+        else
+          conn_info = "#{@cfg[:rs][:seeds].inspect}, set: #{@cfg[:rs][:set]}"
+          log_info "Connecting to MongoDB in RS mode to #{conn_info}"
+          @dba =  Mongo::Client.new([@cfg[:rs][:seeds]], ssl: @cfg[:ssl][:enable], ssl_cert: @cfg[:ssl][:ssl_cert], ssl_key: @cfg[:ssl][:ssl_key], ssl_verify: @cfg[:ssl][:ssl_verify], connect: :replica_set, :database => @cfg[:database] || "dakwak_production")
+        end
+              @dbh = @dba
+        #@dbh = @dba.db(@cfg[:database] || "dakwak_production")
+      end
+
+      true
+    end
+
+    def disconnect()
+      @dba.close
+      @dba = nil
+
+      log_info "disconnected"
+    end
+
+
+    def find(collection, cnd)
+      rescue_connection_failure do
+        entries =  @dbh[collection].find(cnd).sort(:created_at => Mongo::Index::DESCENDING).entries
+        return entries if entries.length > 0
+      end
+
+      return []
+    end
+
+    def find_one(collection, cnd)
+      rescue_connection_failure do
+        return @dbh[collection].find(cnd).sort(:created_at => Mongo::Index::DESCENDING).first
+      end
+
+      return false
+    end
+
+    def find_or_create(collection, args, creation_args = {})
+      rescue_connection_failure do
+        doc = find_one(collection, args)
+        if !doc
+          doc = create!(collection, args.merge(creation_args))
+        end
+        return doc
+      end
+
+      return false
+    end
+
+    def create(collection, args)
+      rescue_connection_failure do
+        args.delete("_id")
+        args.merge!({:created_at => Time.now.utc, :updated_at => Time.now.utc })
+        id = @dbh[collection].insert_one(args)
+        doc = find_one(collection,:_id => id.inserted_ids[0]) 
+        return doc
+      end
+
+      return false
+    end
+
+    def create!(collection, args)
+      rescue_connection_failure do
+        args.delete("_id")
+        args.merge!({:created_at => Time.now.utc, :updated_at => Time.now.utc })
+        id = @dbh[collection].insert_one(args)
+        doc = find_one(collection,:_id => id.inserted_ids[0])
+        return doc
+      end
+
+      return false
+    end
+
+    def update(collection, record, args)
+      rescue_connection_failure do
+        # args.merge!({ :updated_at => Time.now.utc })
+        id = @dbh[collection].update_many({ "_id" => record['_id'] }, args)
+        doc = find(collection, "_id" => record['_id'])
+       end
+
+      return false
+    end
+
+    def update_where(collection, conds, args)
+      rescue_connection_failure do
+        return update(collection, conds ,args)
+      end
+      return false
+    end
+
+
+    def update_all(collection, find_args, update_args)
+      rescue_connection_failure do
+        return @dbh[collection].update(find_args, update_args)
+      end
+
+      return false
+    end
+
+    def remove(collection, args)
+      @dbh[collection].remove(args)
+    end
+
+    # Ensure retry upon failure
+    # Shamelessly stolen from http://api.mongodb.org/ruby/current/file.REPLICA_SETS.html
+    def rescue_connection_failure(max_retries=10)
+      retries = 0
+      begin
+        yield
+      rescue Mongo::Error::NoServerAvailable => ex
+        log_warn "connection to MongoDB was lost, retrying for the #{retries} time"
+        retries += 1
+        raise ex if retries > max_retries
+        sleep(0.5)
+        retry
+      end
+    end
+  end
+end

data/lib/dakwak/utility.rb

@@ -0,0 +1,8 @@
+module Dakwak
+  module Utility
+
+    class << self
+    end
+
+  end
+end