sidekick-client 0.1.0

data/lib/ext/bunny-0.6.0/lib/bunny/subscription09.rb

@@ -0,0 +1,85 @@
+module Bunny
+	
+=begin rdoc
+
+=== DESCRIPTION:
+
+Asks the server to start a "consumer", which is a transient request for messages from a specific
+queue. Consumers last as long as the channel they were created on, or until the client cancels them
+with an _unsubscribe_. Every time a message reaches the queue it is passed to the _blk_ for
+processing. If error occurs, _Bunny_::_ProtocolError_ is raised.
+
+==== OPTIONS:
+* <tt>:consumer_tag => '_tag_'</tt> - Specifies the identifier for the consumer. The consumer tag is
+  local to a connection, so two clients can use the same consumer tags. If this option is not
+  specified a server generated name is used.
+* <tt>:ack => false (_default_) or true</tt> - If set to _false_, the server does not expect an
+  acknowledgement message from the client. If set to _true_, the server expects an acknowledgement
+  message from the client and will re-queue the message if it does not receive one within a time specified
+  by the server.
+* <tt>:exclusive => true or false (_default_)</tt> - Request exclusive consumer access, meaning
+  only this consumer can access the queue.
+* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
+* <tt>:timeout => number of seconds - The subscribe loop will continue to wait for
+  messages until terminated (Ctrl-C or kill command) or this timeout interval is reached.
+* <tt>:message_max => max number messages to process</tt> - When the required number of messages
+  is processed subscribe loop is exited.
+
+==== OPERATION:
+
+Passes a hash of message information to the block, if one has been supplied. The hash contains 
+:header, :payload and :delivery_details. The structure of the data is as follows -
+
+:header has instance variables - 
+  @klass
+  @size
+  @weight
+  @properties is a hash containing -
+    :content_type
+    :delivery_mode
+    :priority
+
+:payload contains the message contents
+
+:delivery details is a hash containing -
+  :consumer_tag
+  :delivery_tag
+  :redelivered
+  :exchange 
+  :routing_key
+
+If the :timeout option is specified then Qrack::ClientTimeout is raised if method times out
+waiting to receive the next message from the queue.
+
+==== EXAMPLES
+
+my_queue.subscribe(:timeout => 5) {|msg| puts msg[:payload]}
+
+my_queue.subscribe(:message_max => 10, :ack => true) {|msg| puts msg[:payload]}
+
+=end
+	
+	class Subscription09 < Qrack::Subscription
+	
+		def setup_consumer
+			client.send_frame(
+				Qrack::Protocol09::Basic::Consume.new({ :reserved_1 => 0,
+																			 					:queue => queue.name,
+																	 		 					:consumer_tag => consumer_tag,
+																	 		 					:no_ack => !ack,
+																								:exclusive => exclusive,
+																	 		 					:nowait => false}.merge(@opts))
+												)
+
+			method = client.next_method
+
+			client.check_response(method,	Qrack::Protocol09::Basic::ConsumeOk,
+				"Error subscribing to queue #{queue.name}")
+
+			@consumer_tag = method.consumer_tag
+		
+		end
+	
+	end
+	
+end

data/lib/ext/bunny-0.6.0/lib/bunny.rb

@@ -0,0 +1,87 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+# Ruby standard libraries
+%w[socket thread timeout logger].each do |file|
+	require file
+end
+
+module Bunny
+
+	class ConnectionError < StandardError; end
+	class ForcedChannelCloseError < StandardError; end
+	class ForcedConnectionCloseError < StandardError; end
+	class MessageError < StandardError; end
+	class ProtocolError < StandardError; end
+	class ServerDownError < StandardError; end
+	class UnsubscribeError < StandardError; end
+	class AcknowledgementError < StandardError; end
+	
+	VERSION = '0.6.0'
+	
+	# Returns the Bunny version number
+
+	def self.version
+		VERSION
+	end
+	
+	# Instantiates new Bunny::Client
+
+	def self.new(opts = {})
+		# Set up Bunny according to AMQP spec version required
+		spec_version = opts[:spec] || '08'
+
+		# Return client
+		setup(spec_version, opts)
+	end
+	
+	# Runs a code block using a short-lived connection
+
+  def self.run(opts = {}, &block)
+    raise ArgumentError, 'Bunny#run requires a block' unless block
+
+		# Set up Bunny according to AMQP spec version required
+		spec_version = opts[:spec] || '08'
+		client = setup(spec_version, opts)
+		
+    begin
+      client.start
+      block.call(client)
+    ensure
+      client.stop
+    end
+
+		# Return success
+		:run_ok
+  end
+
+	private
+	
+	def self.setup(version, opts)	
+		if version == '08'
+			# AMQP 0-8 specification
+			require 'qrack/qrack08'
+			require 'bunny/client08'
+			require 'bunny/exchange08'
+			require 'bunny/queue08'
+			require 'bunny/channel08'
+			require 'bunny/subscription08'
+			
+			client = Bunny::Client.new(opts)
+		else
+			# AMQP 0-9-1 specification
+			require 'qrack/qrack09'
+			require 'bunny/client09'
+			require 'bunny/exchange09'
+			require 'bunny/queue09'
+			require 'bunny/channel09'
+			require 'bunny/subscription09'
+			
+			client = Bunny::Client09.new(opts)
+		end			
+		
+		include Qrack
+
+    client
+	end
+
+end

data/lib/ext/bunny-0.6.0/lib/qrack/channel.rb

@@ -0,0 +1,18 @@
+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/ext/bunny-0.6.0/lib/qrack/client.rb

@@ -0,0 +1,204 @@
+module Qrack
+	
+	class ClientTimeout < Timeout::Error; end
+  class ConnectionTimeout < 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
+
+		def initialize(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
+			@logger = nil
+			create_logger if @logging
+			@message_in = false
+			@message_out = false
+			@connecting = false
+			@channels ||= []
+			# Create channel 0
+      @channel = create_channel()
+			@exchanges ||= {}
+			@queues ||= {}
+		end
+		
+=begin rdoc
+
+=== DESCRIPTION:
+
+Closes all active communication channels and connection. If an error occurs a
+_Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <tt>:not_connected</tt>.
+
+==== RETURNS:
+
+<tt>:not_connected</tt> if successful.
+
+=end
+
+		def close
+			# Close all active channels
+			channels.each do |c|
+				c.close if c.open?
+			end
+
+			# Close connection to AMQP server
+			close_connection
+
+			# 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 = {})
+      next_frame(options).payload
+    end
+
+		alias next_method next_payload
+
+    def read(*args)
+      send_command(:read, *args)
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+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.
+
+==== OPTIONS:
+
+* <tt>:timeout => number of seconds (default = 0.1) - The method will wait for a return
+  message until this timeout interval is reached.
+
+==== RETURNS:
+
+<tt>{:header => nil, :payload => :no_return, :return_details => nil}</tt> if message is
+not returned before timeout.
+<tt>{:header, :return_details, :payload}</tt> if message is returned. <tt>:return_details</tt> is
+a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
+
+=end
+
+		def returned_message(opts = {})
+			
+			begin		
+				frame = next_frame(:timeout => opts[:timeout] || 0.1)
+			rescue Qrack::ClientTimeout
+				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
+        @socket.__send__(cmd, *args)
+      rescue Errno::EPIPE, IOError => e
+        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 = timeout(@connect_timeout, ConnectionTimeout) do
+          TCPSocket.new(host, port)
+        end
+
+        if 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/ext/bunny-0.6.0/lib/qrack/protocol/protocol08.rb

@@ -0,0 +1,132 @@
+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