sparqcode_bunny 0.0.1

data/lib/qrack/amq-client-url.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+################################################################
+#                  DO NOT EDIT THIS FILE !                     #
+# The file comes from https://github.com/ruby-amqp/amq-client, #
+# it's located in lib/amq/client/settings.rb, so if you want   #
+# to make some changes, please do them in the amq-client repo. #
+################################################################
+
+# TODO: When we start to work on porting Bunny on AMQ Client,
+# this file will become obsolete.
+
+require "uri"
+
+module AMQ
+  module Client
+    # @see AMQ::Client::Settings.configure
+    module Settings
+      # @private
+      AMQP_PORTS = {"amqp" => 5672, "amqps" => 5671}.freeze
+
+      # @private
+      AMQPS = "amqps".freeze
+
+      # Default connection settings used by AMQ clients
+      #
+      # @see AMQ::Client::Settings.configure
+      def self.default
+        @default ||= {
+          # server
+          :host  => "127.0.0.1",
+          :port  => AMQ::Protocol::DEFAULT_PORT,
+
+          # login
+          :user  => "guest",
+          :pass  => "guest",
+          :vhost => "/",
+
+          # connection timeout
+          :timeout => nil,
+
+          # logging
+          :logging => false,
+
+          # ssl
+          :ssl => false,
+
+          # broker
+          # if you want to load broker-specific extensions
+          :broker => nil,
+
+          :frame_max => 131072
+        }
+      end
+
+
+      def self.client_properties
+        @client_properties ||= {
+          :platform    => ::RUBY_DESCRIPTION,
+          :product     => "AMQ Client",
+          :information => "http://github.com/ruby-amqp/amq-client",
+          :version     => AMQ::Client::VERSION
+        }
+      end
+
+
+      # Merges given configuration parameters with defaults and returns
+      # the result.
+      #
+      # @param [Hash] Configuration parameters to use.
+      #
+      # @option settings [String] :host ("127.0.0.1") Hostname AMQ broker runs on.
+      # @option settings [String] :port (5672) Port AMQ broker listens on.
+      # @option settings [String] :vhost ("/") Virtual host to use.
+      # @option settings [String] :user ("guest") Username to use for authentication.
+      # @option settings [String] :pass ("guest") Password to use for authentication.
+      # @option settings [String] :ssl (false) Should be use TLS (SSL) for connection?
+      # @option settings [String] :timeout (nil) Connection timeout.
+      # @option settings [String] :logging (false) Turns logging on or off.
+      # @option settings [String] :broker (nil) Broker name (use if you intend to use broker-specific features).
+      # @option settings [Fixnum] :frame_max (131072) Maximum frame size to use. If broker cannot support frames this large, broker's maximum value will be used instead.
+      #
+      # @return [Hash] Merged configuration parameters.
+      def self.configure(settings = nil)
+        case settings
+        when Hash then
+          if username = settings.delete(:username)
+            settings[:user] ||= username
+          end
+
+          if password = settings.delete(:password)
+            settings[:pass] ||= password
+          end
+
+
+          self.default.merge(settings)
+        when String then
+          settings = self.parse_amqp_url(settings)
+          self.default.merge(settings)
+        when NilClass then
+          self.default
+        end
+      end
+
+      # Parses AMQP connection URI and returns its components as a hash.
+      #
+      # h2. vhost naming schemes
+      #
+      # It is convenient to be able to specify the AMQP connection
+      # parameters as a URI string, and various "amqp" URI schemes
+      # exist.  Unfortunately, there is no standard for these URIs, so
+      # while the schemes share the basic idea, they differ in some
+      # details.  This implementation aims to encourage URIs that work
+      # as widely as possible.
+      #
+      # The URI scheme should be "amqp", or "amqps" if SSL is required.
+      #
+      # The host, port, username and password are represented in the
+      # authority component of the URI in the same way as in http URIs.
+      #
+      # The vhost is obtained from the first segment of the path, with the
+      # leading slash removed.  The path should contain only a single
+      # segment (i.e, the only slash in it should be the leading one).
+      # If the vhost is to include slashes or other reserved URI
+      # characters, these should be percent-escaped.
+      #
+      # @example How vhost is parsed
+      #
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com")            # => vhost is nil, so default (/) will be used
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/")           # => vhost is an empty string
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/%2Fvault")   # => vhost is /vault
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/production") # => vhost is production
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/a.b.c")      # => vhost is a.b.c
+      #   AMQ::Client::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/foo/bar")    # => ArgumentError
+      #
+      #
+      # @param [String] connection_string AMQP connection URI, à la JDBC connection string. For example: amqp://bus.megacorp.internal:5877.
+      # @return [Hash] Connection parameters (:username, :password, :vhost, :host, :port, :ssl)
+      #
+      # @raise [ArgumentError] When connection URI schema is not amqp or amqps, or the path contains multiple segments
+      #
+      # @see http://bit.ly/ks8MXK Connecting to The Broker documentation guide
+      # @api public
+      def self.parse_amqp_url(connection_string)
+        uri = URI.parse(connection_string)
+        raise ArgumentError.new("Connection URI must use amqp or amqps schema (example: amqp://bus.megacorp.internal:5766), learn more at http://bit.ly/ks8MXK") unless %w{amqp amqps}.include?(uri.scheme)
+
+        opts = {}
+
+        opts[:scheme] = uri.scheme
+        opts[:user]   = URI.unescape(uri.user) if uri.user
+        opts[:pass]   = URI.unescape(uri.password) if uri.password
+        opts[:host]   = uri.host if uri.host
+        opts[:port]   = uri.port || AMQ::Client::Settings::AMQP_PORTS[uri.scheme]
+        opts[:ssl]    = uri.scheme == AMQ::Client::Settings::AMQPS
+        if uri.path =~ %r{^/(.*)}
+          raise ArgumentError.new("#{uri} has multiple-segment path; please percent-encode any slashes in the vhost name (e.g. /production => %2Fproduction). Learn more at http://bit.ly/amqp-gem-and-connection-uris") if $1.index('/')
+          opts[:vhost] = URI.unescape($1)
+        end
+
+        opts
+      end
+    end
+  end
+end

data/lib/qrack/channel.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Qrack
+  # Channel ancestor class
+  class Channel
+
+    attr_accessor :number, :active, :frame_buffer
+    attr_reader :client
+
+    def initialize(client)
+      @frame_buffer = []
+      @client = client
+      @number = client.channels.size
+      @active = false
+      client.channels[@number] = self
+    end
+
+  end
+
+end

data/lib/qrack/client.rb

@@ -0,0 +1,235 @@
+# encoding: utf-8
+
+begin
+  # try loading AMQ::Client::Setttings form the amq client gem, if it has been already loaded
+  # this avoids "warning: already initialized constant AMQP_PORTS"
+  require "amq/client/settings"
+rescue LoadError
+  require "qrack/amq-client-url"
+end
+
+module Qrack
+
+  class ClientTimeout < Timeout::Error; end
+  class ConnectionTimeout < Timeout::Error; end
+  class FrameTimeout < Timeout::Error; end
+
+  # Client ancestor class
+  class Client
+
+    CONNECT_TIMEOUT = 5.0
+    RETRY_DELAY     = 10.0
+
+    attr_reader   :status, :host, :vhost, :port, :logging, :spec, :heartbeat
+    attr_accessor :channel, :logfile, :exchanges, :queues, :channels, :message_in, :message_out, :connecting
+
+    # Temporary hack to make Bunny 0.7 work with port number in AMQP URL.
+    # This is not necessary on Bunny 0.8 as it removes support of AMQP 0.8.
+    attr_reader :__opts__
+
+    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
+      opts = case connection_string_or_opts
+      when String then
+        AMQ::Client::Settings.parse_amqp_url(connection_string_or_opts)
+      when Hash then
+        connection_string_or_opts
+      else
+        Hash.new
+      end.merge(opts)
+
+      # Temporary hack to make Bunny 0.7 work with port number in AMQP URL.
+      # This is not necessary on Bunny 0.8 as it removes support of AMQP 0.8.
+      @__opts__ = opts
+
+
+      @host   = opts[:host] || 'localhost'
+      @user   = opts[:user]  || 'guest'
+      @pass   = opts[:pass]  || 'guest'
+      @vhost  = opts[:vhost] || '/'
+      @logfile = opts[:logfile] || nil
+      @logging = opts[:logging] || false
+      @ssl = opts[:ssl] || false
+      @verify_ssl = opts[:verify_ssl].nil? || opts[:verify_ssl]
+      @status = :not_connected
+      @frame_max = opts[:frame_max] || 131072
+      @channel_max = opts[:channel_max] || 0
+      @heartbeat = opts[:heartbeat] || 0
+      @connect_timeout = opts[:connect_timeout] || CONNECT_TIMEOUT
+      @read_write_timeout = opts[:socket_timeout]
+      @read_write_timeout = nil if @read_write_timeout == 0
+      @disconnect_timeout = @read_write_timeout || @connect_timeout
+      @logger = nil
+      create_logger if @logging
+      @message_in = false
+      @message_out = false
+      @connecting = false
+      @channels ||= []
+      # Create channel 0
+      @channel = create_channel()
+      @exchanges ||= {}
+      @queues ||= {}
+    end
+
+
+    # Closes all active communication channels and connection. If an error occurs a @Bunny::ProtocolError@ is raised. If successful, @Client.status@ is set to @:not_connected@.
+
+    # @return [Symbol] @:not_connected@ if successful.
+    def close
+      return if @socket.nil? || @socket.closed?
+
+      # Close all active channels
+      channels.each do |c|
+        Bunny::Timer::timeout(@disconnect_timeout) { c.close } if c.open?
+      end
+
+      # Close connection to AMQP server
+      Bunny::Timer::timeout(@disconnect_timeout) { close_connection }
+
+    rescue Exception
+      # http://cheezburger.com/Asset/View/4033311488
+    ensure
+      # Clear the channels
+      @channels = []
+
+      # Create channel 0
+      @channel = create_channel()
+
+      # Close TCP Socket
+      close_socket
+    end
+
+    alias stop close
+
+    def connected?
+      status == :connected
+    end
+
+    def connecting?
+      connecting
+    end
+
+    def logging=(bool)
+      @logging = bool
+      create_logger if @logging
+    end
+
+    def next_payload(options = {})
+      res = next_frame(options)
+      res.payload if res
+    end
+
+    alias next_method next_payload
+
+    def read(*args)
+      send_command(:read, *args)
+      # Got a SIGINT while waiting; give any traps a chance to run
+    rescue Errno::EINTR
+      retry
+    end
+
+  # Checks to see whether or not an undeliverable message has been returned as a result of a publish
+  # with the <tt>:immediate</tt> or <tt>:mandatory</tt> options.
+
+  # @param [Hash] opts Options.
+  # @option opts [Numeric] :timeout (0.1) The method will wait for a return message until this timeout interval is reached.
+  # @return [Hash] @{:header => nil, :payload => :no_return, :return_details => nil}@ if message is not returned before timeout. @{:header, :return_details, :payload}@ if message is returned. @:return_details@ is a hash @{:reply_code, :reply_text, :exchange, :routing_key}@.
+    def returned_message(opts = {})
+
+      begin
+        frame = next_frame(:timeout => opts[:timeout] || 0.1)
+      rescue Qrack::FrameTimeout
+        return {:header => nil, :payload => :no_return, :return_details => nil}
+      end
+
+      method = frame.payload
+      header = next_payload
+
+      # If maximum frame size is smaller than message payload body then message
+      # will have a message header and several message bodies
+      msg = ''
+      while msg.length < header.size
+        msg << next_payload
+      end
+
+      # Return the message and related info
+      {:header => header, :payload => msg, :return_details => method.arguments}
+    end
+
+    def switch_channel(chann)
+      if (0...channels.size).include? chann
+        @channel = channels[chann]
+        chann
+      else
+        raise RuntimeError, "Invalid channel number - #{chann}"
+      end
+    end
+
+    def write(*args)
+      send_command(:write, *args)
+    end
+
+    private
+
+    def close_socket(reason=nil)
+      # Close the socket. The server is not considered dead.
+      @socket.close if @socket and not @socket.closed?
+      @socket   = nil
+      @status   = :not_connected
+    end
+
+    def create_logger
+      @logfile ? @logger = Logger.new("#{logfile}") : @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+    end
+
+    def send_command(cmd, *args)
+      begin
+        raise Bunny::ConnectionError, 'No connection - socket has not been created' if !@socket
+        if @read_write_timeout
+          Bunny::Timer::timeout(@read_write_timeout, Qrack::ClientTimeout) do
+            @socket.__send__(cmd, *args)
+          end
+        else
+          @socket.__send__(cmd, *args)
+        end
+      rescue Errno::EPIPE, Errno::EAGAIN, Qrack::ClientTimeout, IOError => e
+        # Ensure we close the socket when we are down to prevent further
+        # attempts to write to a closed socket
+        close_socket
+        raise Bunny::ServerDownError, e.message
+      end
+    end
+
+    def socket
+      return @socket if @socket and (@status == :connected) and not @socket.closed?
+
+      begin
+        # Attempt to connect.
+        @socket = Bunny::Timer::timeout(@connect_timeout, ConnectionTimeout) do
+          TCPSocket.new(host, port)
+        end
+
+        if Socket.constants.include?('TCP_NODELAY') || Socket.constants.include?(:TCP_NODELAY)
+          @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+        end
+
+        if @ssl
+          require 'openssl' unless defined? OpenSSL::SSL
+          @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+          @socket.sync_close = true
+          @socket.connect
+          @socket.post_connection_check(host) if @verify_ssl
+          @socket
+        end
+      rescue => e
+        @status = :not_connected
+        raise Bunny::ServerDownError, e.message
+      end
+
+      @socket
+    end
+
+  end
+
+end

data/lib/qrack/errors.rb

@@ -0,0 +1,5 @@
+module Qrack
+  # Errors
+  class BufferOverflowError < StandardError; end
+  class InvalidTypeError < StandardError; end
+end

data/lib/qrack/protocol/protocol08.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+module Qrack
+  module Protocol
+    #:stopdoc:
+    class Class::Method
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        if args.size == 1 and args.first.is_a? Transport::Buffer
+          buf = args.shift
+        else
+          buf = nil
+        end
+
+        self.class.arguments.each do |type, name|
+          val = buf ? buf.read(type) :
+            args.shift || opts[name] || opts[name.to_s]
+          instance_variable_set("@#{name}", val)
+        end
+      end
+
+      def arguments
+        self.class.arguments.inject({}) do |hash, (type, name)|
+          hash.update name => instance_variable_get("@#{name}")
+        end
+      end
+
+      def to_binary
+        buf = Transport::Buffer.new
+        buf.write :short, self.class.parent.id
+        buf.write :short, self.class.id
+
+        bits = []
+
+        self.class.arguments.each do |type, name|
+          val = instance_variable_get("@#{name}")
+          if type == :bit
+            bits << (val || false)
+          else
+            unless bits.empty?
+              buf.write :bit, bits
+              bits = []
+            end
+            buf.write type, val
+          end
+        end
+
+        buf.write :bit, bits unless bits.empty?
+        buf.rewind
+
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport::Method.new(self, channel)
+      end
+    end
+
+    class Header
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        first = args.shift
+
+        if first.is_a? ::Class and first.ancestors.include? Protocol::Class
+          @klass = first
+          @size = args.shift || 0
+          @weight = args.shift || 0
+          @properties = opts
+
+        elsif first.is_a? Transport::Buffer or first.is_a? String
+          buf = first
+          buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
+
+          @klass = Protocol.classes[buf.read(:short)]
+          @weight = buf.read(:short)
+          @size = buf.read(:longlong)
+
+          props = buf.read(:properties, *klass.properties.map{|type,_| type })
+          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
+
+        else
+          raise ArgumentError, 'Invalid argument'
+        end
+
+      end
+      attr_accessor :klass, :size, :weight, :properties
+
+      def to_binary
+        buf = Transport::Buffer.new
+        buf.write :short, klass.id
+        buf.write :short, weight # XXX rabbitmq only supports weight == 0
+        buf.write :longlong, size
+        buf.write :properties, (klass.properties.map do |type, name|
+                                  [ type, properties[name] || properties[name.to_s] ]
+                                end)
+        buf.rewind
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport::Header.new(self, channel)
+      end
+
+      def == header
+        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
+          eql and __send__(field) == header.__send__(field)
+        end
+      end
+
+      def method_missing meth, *args, &blk
+        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] : super
+      end
+    end
+
+    def self.parse buf
+      buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
+      class_id, method_id = buf.read(:short, :short)
+      classes[class_id].methods[method_id].new(buf)
+    end
+
+  end
+end

data/lib/qrack/protocol/protocol09.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+module Qrack
+  module Protocol09
+    #:stopdoc:
+    class Class::Method
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        if args.size == 1 and args.first.is_a? Transport09::Buffer
+          buf = args.shift
+        else
+          buf = nil
+        end
+
+        self.class.arguments.each do |type, name|
+          val = buf ? buf.read(type) :
+            args.shift || opts[name] || opts[name.to_s]
+          instance_variable_set("@#{name}", val)
+        end
+      end
+
+      def arguments
+        self.class.arguments.inject({}) do |hash, (type, name)|
+          hash.update name => instance_variable_get("@#{name}")
+        end
+      end
+
+      def to_binary
+        buf = Transport09::Buffer.new
+        buf.write :short, self.class.parent.id
+        buf.write :short, self.class.id
+
+        bits = []
+
+        self.class.arguments.each do |type, name|
+          val = instance_variable_get("@#{name}")
+          if type == :bit
+            bits << (val || false)
+          else
+            unless bits.empty?
+              buf.write :bit, bits
+              bits = []
+            end
+            buf.write type, val
+          end
+        end
+
+        buf.write :bit, bits unless bits.empty?
+        buf.rewind
+
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport09::Method.new(self, channel)
+      end
+    end
+
+    class Header
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+
+        first = args.shift
+
+        if first.is_a? ::Class and first.ancestors.include? Protocol09::Class
+          @klass = first
+          @size = args.shift || 0
+          @weight = args.shift || 0
+          @properties = opts
+
+        elsif first.is_a? Transport09::Buffer or first.is_a? String
+          buf = first
+          buf = Transport09::Buffer.new(buf) unless buf.is_a? Transport09::Buffer
+
+          @klass = Protocol09.classes[buf.read(:short)]
+          @weight = buf.read(:short)
+          @size = buf.read(:longlong)
+
+          props = buf.read(:properties, *klass.properties.map{|type,_| type })
+          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
+
+        else
+          raise ArgumentError, 'Invalid argument'
+        end
+
+      end
+      attr_accessor :klass, :size, :weight, :properties
+
+      def to_binary
+        buf = Transport09::Buffer.new
+        buf.write :short, klass.id
+        buf.write :short, weight # XXX rabbitmq only supports weight == 0
+        buf.write :longlong, size
+        buf.write :properties, (klass.properties.map do |type, name|
+                                  [ type, properties[name] || properties[name.to_s] ]
+                                end)
+        buf.rewind
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Transport09::Header.new(self, channel)
+      end
+
+      def == header
+        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
+          eql and __send__(field) == header.__send__(field)
+        end
+      end
+
+      def method_missing meth, *args, &blk
+        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] :
+          super
+      end
+    end
+
+    def self.parse buf
+      buf = Transport09::Buffer.new(buf) unless buf.is_a? Transport09::Buffer
+      class_id, method_id = buf.read(:short, :short)
+      classes[class_id].methods[method_id].new(buf)
+    end
+
+  end
+end