mqtt 0.0.3 → 0.0.4

data/NEWS

@@ -1,5 +1,10 @@
 = Ruby MQTT NEWS
 
+== Ruby MQTT Version 0.0.4 (2009-02-22)
+
+Re-factored packet encoding/decoding into one class per packet type.
+Added MQTT::Proxy class for implementing an MQTT proxy.
+
 == Ruby MQTT Version 0.0.3 (2009-02-08)
 
 Added checking of Connection Acknowledgement.

data/README

@@ -13,7 +13,7 @@ You may get the latest stable version from Rubyforge. Source gems are also avail
 == Synopsis
 
   require 'rubygems'
-  require 'mqtt'
+  require 'mqtt/client'
   
   # Publish example
   mqtt = MQTT::Client.new('mqtt.example.com')
@@ -34,16 +34,17 @@ You may get the latest stable version from Rubyforge. Source gems are also avail
 
 == TODO
 
-* Process acknowledgement packets
-* Create classes for each type of packet?
-* More validations of data/parameters
-* Implement exception throwing
 * Implement Will and Testament
+* Process acknowledgement packets / Implement QOS 1 in client
+* More validations of data/parameters
+* More error checking and exception throwing
+  - Check that packet data is valid - don't blindly read values
+  - Subscribe and Unsubscribe packets should always have QOS of 1
 * More examples
 * Integration tests
 * Refactor to add callbacks that are called from seperate thread
-* Implement QOS Level 1
-* Implement QOS Level 2
+* Implement QOS Level 2 in client
+* Prevent proxy from connecting to itself
 * Add support for binding socket to specific local address
 
 == Resources

data/Rakefile

@@ -8,7 +8,7 @@ require 'spec/rake/verify_rcov'
 
 
 NAME = "mqtt"
-VERS = "0.0.3"
+VERS = "0.0.4"
 CLEAN.include ['pkg', 'rdoc']
 
 spec = Gem::Specification.new do |s|

data/examples/livetext.rb

@@ -2,9 +2,9 @@
 
 $:.unshift File.dirname(__FILE__)+'/../lib'
 
-require 'mqtt'
+require 'mqtt/client'
 
-client = MQTT::Client.new('hadrian.aelius.com')
+client = MQTT::Client.new('mqtt.example.com')
 client.connect do
   client.subscribe('livetext/#')
   loop do

data/examples/readonly_proxy.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__)+'/../lib'
+
+require 'mqtt/proxy'
+
+proxy = MQTT::Proxy.new(
+    :local_host => '0.0.0.0',
+    :local_port => 1883,
+    :broker_host => 'mqtt.example.com',
+    :broker_port => 1883
+)
+
+proxy.client_filter = lambda { |packet|
+  puts "From client: #{packet.inspect}"
+  return packet
+}
+
+proxy.broker_filter = lambda { |packet|
+  puts "From broker: #{packet.inspect}"
+  return packet
+}
+
+# Start the proxy
+proxy.run

data/examples/simple_get.rb

@@ -2,7 +2,7 @@
 
 $:.unshift File.dirname(__FILE__)+'/../lib'
 
-require 'mqtt'
+require 'mqtt/client'
 
 client = MQTT::Client.new('mqtt.example.com')
 client.connect do

data/examples/simple_publish.rb

@@ -2,7 +2,7 @@
 
 $:.unshift File.dirname(__FILE__)+'/../lib'
 
-require 'mqtt'
+require 'mqtt/client'
 
 client = MQTT::Client.new('mqtt.example.com')
 client.connect do |c|

data/lib/mqtt.rb

@@ -1,29 +1,8 @@
 #!/usr/bin/env ruby
 
-require 'mqtt/client'
-
 # Pure-ruby implementation of the MQTT protocol
 module MQTT
 
-  PACKET_TYPES = [
-    nil,
-    :connect,      # Client request to connect to Broker
-    :connack,      # Connect Acknowledgment
-    :publish,      # Publish message
-    :puback,       # Publish Acknowledgment
-    :pubrec,       # Publish Received (assured delivery part 1)
-    :pubrel,       # Publish Release (assured delivery part 2)
-    :pubcomp,      # Publish Complete (assured delivery part 3)
-    :subscribe,    # Client Subscribe request
-    :suback,       # Subscribe Acknowledgment
-    :unsubscribe,  # Client Unsubscribe request
-    :unsuback,     # Unsubscribe Acknowledgment
-    :pingreq,      # PING Request
-    :pingresp,     # PING Response
-    :disconnect,   # Client is Disconnecting
-    nil
-  ]
-  
   class Exception < Exception
   
   end

data/lib/mqtt/client.rb

@@ -48,22 +48,12 @@ module MQTT
         @socket = TCPSocket.new(@remote_host,@remote_port)
 
         # Protocol name and version
-        packet = MQTT::Packet.new(:type => :connect)
-        packet.add_string('MQIsdp')
-        packet.add_bytes(0x03)
-        
-        # Connect flags
-        connect_flags = 0x00
-        connect_flags ||= 0x02 if @clean_start
-        # FIXME: implement Will and Testament
-        packet.add_bytes(connect_flags)
-        
-        # Keep Alive timer: 10 seconds
-        packet.add_short(@keep_alive)
-        
-        # Add the client identifier
-        packet.add_string(@client_id)
-        
+        packet = MQTT::Packet::Connect.new(
+          :clean_start => @clean_start,
+          :keep_alive => @keep_alive,
+          :client_id => @client_id
+        )
+
         # Send packet
         send_packet(packet)
 
@@ -89,7 +79,7 @@ module MQTT
     def disconnect(send_msg=true)
       if connected?
         if send_msg
-          packet = MQTT::Packet.new(:type => :disconnect)
+          packet = MQTT::Packet::Disconnect.new
           send_packet(packet)
         end
         @read_thread.kill if @read_thread and @read_thread.alive?
@@ -106,30 +96,21 @@ module MQTT
   
     # Send a MQTT ping message to indicate that the MQTT client is alive.
     def ping
-      packet = MQTT::Packet.new(:type => :pingreq)
+      packet = MQTT::Packet::Pingreq.new
       send_packet(packet)
       @last_pingreq = Time.now
     end
 
     # Publish a message on a particular topic to the MQTT broker.
     def publish(topic, payload, retain=false, qos=0)
-      packet = MQTT::Packet.new(
-        :type => :publish,
+      packet = MQTT::Packet::Publish.new(
         :qos => qos,
-        :retain => retain
+        :retain => retain,
+        :topic => topic,
+        :payload => payload,
+        :message_id => @message_id.next
       )
-      
-      # Add the topic name
-      packet.add_string(topic)
-      
-      # Add Message ID for qos1 and qos2
-      unless qos == 0
-        packet.add_short(@message_id.next)
-      end
-      
-      # Add the packet payload
-      packet.add_data(payload)
-      
+
       # Send the packet
       send_packet(packet)
     end
@@ -147,27 +128,10 @@ module MQTT
     #   client.subscribe( 'a/b' => 0, 'c/d' => 1 )
     #
     def subscribe(*topics)
-      array = []
-      topics.each do |item|
-        if item.is_a?(Hash)
-          # Convert hash into an ordered array of arrays
-          array += item.sort
-        elsif item.is_a?(Array)
-          # Already in [topic,qos] format 
-          array.push item
-        else
-          # Default to QOS 0
-          array.push [item.to_s,0]
-        end
-      end
-      
-      # Create the packet
-      packet = MQTT::Packet.new(:type => :subscribe, :qos => 1)
-      packet.add_short(@message_id.next)
-      array.each do |item|
-        packet.add_string(item[0])
-        packet.add_bytes(item[1])
-      end
+      packet = MQTT::Packet::Subscribe.new(
+        :topics => topics,
+        :message_id => @message_id.next
+      )
       send_packet(packet)
     end
     
@@ -180,17 +144,17 @@ module MQTT
     def get
       # Wait for a packet to be available
       packet = @read_queue.pop
-      
-      # Parse the variable header
-      topic = packet.shift_string
-      msg_id = packet.shift_short unless (packet.qos == 0)
-      return topic,packet.body
+      topic = packet.topic
+      payload = packet.payload
+      return topic,payload
     end
     
     # Send a unsubscribe message for one or more topics on the MQTT broker
     def unsubscribe(*topics)
-      packet = MQTT::Packet.new(:type => :unsubscribe, :qos => 1)
-      topics.each { |topic| packet.add_string(topic) }
+      packet = MQTT::Packet::Unsubscribe.new(
+        :topics => topics,
+        :message_id => @message_id.next
+      )
       send_packet(packet)
     end
   
@@ -205,7 +169,7 @@ module MQTT
         unless result.nil?
           # Yes - read in the packet
           packet = MQTT::Packet.read(@socket)
-          if packet.type == :publish
+          if packet.class == MQTT::Packet::Publish
             # Add to queue
             @read_queue.push(packet)
           else
@@ -236,23 +200,13 @@ module MQTT
     def receive_connack
       Timeout.timeout(@ack_timeout) do
         packet = MQTT::Packet.read(@socket)
-        if packet.type != :connack
-          raise MQTT::ProtocolException.new("Response wan't a connection acknowledgement: #{packet.type}") 
+        if packet.class != MQTT::Packet::Connack
+          raise MQTT::ProtocolException.new("Response wan't a connection acknowledgement: #{packet.class}") 
         end
         
-        # Read in the return code
-        byte1, return_code = packet.shift_bytes(2)
-        if return_code == 0x00
-          # Success
-          nil
-        elsif return_code == 0x01
-          raise MQTT::ProtocolException.new("Connection refused: unacceptable protocol version")
-        elsif return_code == 0x02
-          raise MQTT::ProtocolException.new("Connection refused: client identifier rejected")
-        elsif return_code == 0x03
-          raise MQTT::ProtocolException.new("Connection refused: broker unavailable")
-        else
-          raise MQTT::ProtocolException.new("Connection refused: #{return_code}")
+        # Check the return code
+        if packet.return_code != 0x00
+          raise MQTT::ProtocolException.new(packet.return_msg)
         end
       end
     end

data/lib/mqtt/packet.rb

@@ -7,19 +7,19 @@ module MQTT
   # Class representing a MQTT Packet
   # Performs binary encoding and decoding of headers
   class Packet
-    attr_reader :type      # The packet type
     attr_reader :dup       # Duplicate delivery flag
     attr_reader :retain    # Retain flag
     attr_reader :qos       # Quality of Service level
-    attr_reader :body      # Packet's body (everything after fixed header)
   
     # Read in a packet from a socket
     def self.read(socket)
-
-      # Create a packet object
+      # Read in the packet header and work out the class
       header = read_byte(socket)
-      packet = MQTT::Packet.new(
-        :type => ((header & 0xF0) >> 4),
+      type_id = ((header & 0xF0) >> 4)
+      packet_class = MQTT::PACKET_TYPES[type_id]
+      
+      # Create a new packet object
+      packet = packet_class.new(
         :dup => ((header & 0x08) >> 3),
         :qos => ((header & 0x06) >> 1),
         :retain => ((header & 0x01) >> 0)
@@ -36,39 +36,22 @@ module MQTT
       # FIXME: only allow 4 bytes?
 
       # Read in the packet body
-      packet.body = socket.read(body_len)
+      packet.parse_body( socket.read(body_len) )
 
       return packet
     end
 
     # Create a new empty packet
     def initialize(args={})
-      self.type = args[:type] || :invalid
       self.dup = args[:dup] || false
       self.qos = args[:qos] || 0
       self.retain = args[:retain] || false
-      self.body = args[:body] || ''
     end
     
-    # Set the packet type
-    # Can either by the packet type id (integer)
-    # Or the packet type as a symbol/string
-    # See the MQTT module for an enumeration of packet types.
-    def type=(arg)
-      if arg.kind_of?(Integer)
-        # Convert type identifier to symbol
-        @type = MQTT::PACKET_TYPES[arg]
-      else
-        @type = arg.to_sym
-        # FIXME: raise exception if packet type is invalid?
-      end
-    end
-
-    # Return the identifer for this packet type
+    # Get the identifer for this packet type
     def type_id
-      raise "No packet type set for this packet" if @type.nil?
-      index = MQTT::PACKET_TYPES.index(@type)
-      raise "Invalid packet type: #{@type}" if index.nil?
+      index = MQTT::PACKET_TYPES.index(self.class)
+      raise "Invalid packet type: #{self.class}" if index.nil?
       return index
     end
     
@@ -94,62 +77,17 @@ module MQTT
     def qos=(arg)
       @qos = arg.to_i
     end
-    
-    # Set (replace) the packet body
-    def body=(arg)
-      # FIXME: only allow 268435455 bytes?
-      @body = arg.to_s
-    end
-
-
-
-
-    
-    # Add an array of bytes to the end of the packet's body
-    def add_bytes(*bytes)
-      @body += bytes.pack('C*')
-    end
 
-    # Add a 16-bit unsigned integer to the end of the packet's body
-    def add_short(val)
-      @body += [val.to_i].pack('n')
-    end
-    
-    # Add some raw data to the end of the packet's body
-    def add_data(data)
-      data = data.to_s unless data.is_a?(String)
-      @body += data
-    end
-
-    # Add a string to the end of the packet's body
-    # (preceded by the length of the string)
-    def add_string(str)
-      str = str.to_s unless str.is_a?(String)
-      add_short(str.size)
-      add_data(str)
-    end
-
-
-    # Remove a 16-bit unsigned integer from the front on the body
-    def shift_short
-      bytes = @body.slice!(0..1)
-      bytes.unpack('n').first
-    end
-    
-    # Remove n bytes from the front on the body
-    def shift_bytes(bytes)
-      @body.slice!(0...bytes).unpack('C*')
-    end
-    
-    # Remove n bytes from the front on the body
-    def shift_data(bytes)
-      @body.slice!(0...bytes)
+    # Parse the body (variable header and payload) of a packet
+    def parse_body(buffer)
+      unless buffer.size == 0
+        raise MQTT::ProtocolException.new("Error: parse_body was not sub-classed for a packet with a payload")
+      end
     end
     
-    # Remove string from the front on the body
-    def shift_string
-      len = shift_short
-      shift_data(len)
+    # Get serialisation of packet's body (variable header and payload)
+    def encode_body
+      '' # No body by default
     end
 
     
@@ -163,8 +101,11 @@ module MQTT
         (retain ? 0x1 : 0x0)
       ]
       
+      # Get the packet's variable header and payload
+      body = self.encode_body
+      
       # Build up the body length field bytes
-      body_size = @body.size
+      body_size = body.size
       begin
         digit = (body_size % 128)
         body_size = (body_size / 128)
@@ -174,24 +115,493 @@ module MQTT
       end while (body_size > 0)
 
       # Convert header to binary and add on body
-      header.pack('C*') + @body
+      header.pack('C*') + body
+    end
+
+
+    protected
+    
+    # Encode an array of bytes and return them
+    def encode_bytes(*bytes)
+      bytes.pack('C*')
+    end
+
+    # Encode a 16-bit unsigned integer and return it
+    def encode_short(val)
+      [val.to_i].pack('n')
+    end
+
+    # Encode a string and return it
+    # (preceded by the length of the string)
+    def encode_string(str)
+      str = str.to_s unless str.is_a?(String)
+      encode_short(str.size) + str
+    end
+    
+    # Remove a 16-bit unsigned integer from the front of buffer
+    def shift_short(buffer)
+      bytes = buffer.slice!(0..1)
+      bytes.unpack('n').first
     end
     
-    def inspect
-      format("#<MQTT::Packet:0x%01x ", object_id)+
-      "type=#{@type}, dup=#{@dup}, retain=#{@retain}, "+
-      "qos=#{@qos}, body.size=#{@body.size}>"
+    # Remove one byte from the front of the string
+    def shift_byte(buffer)
+      buffer.slice!(0...1).unpack('C').first
     end
     
+    # Remove n bytes from the front of buffer
+    def shift_data(buffer,bytes)
+      buffer.slice!(0...bytes)
+    end
+    
+    # Remove string from the front of buffer
+    def shift_string(buffer)
+      len = shift_short(buffer)
+      shift_data(buffer,len)
+    end
+
+   
     private
     
-    # Read and unpack a single byte from socket
+    # Read and unpack a single byte from a socket
     def self.read_byte(socket)
       byte = socket.read(1)
       raise MQTT::ProtocolException if byte.nil?
       byte.unpack('C').first
     end
+
+
+
+    ## PACKET SUBCLASSES ##
+    
+
+    # Class representing an MQTT Publish message
+    class Publish < MQTT::Packet
+      attr_accessor :topic
+      attr_accessor :message_id
+      attr_accessor :payload
+
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.topic = args[:topic] || nil
+        self.message_id = args[:message_id] || 0
+        self.payload = args[:payload] || ''
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        body = ''
+        raise "Invalid topic name when serialising packet" if @topic.nil?
+        body += encode_string(@topic)
+        body += encode_short(@message_id) unless qos == 0
+        body += payload.to_s
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a Publish packet
+      def parse_body(buffer)
+        @topic = shift_string(buffer)
+        @message_id = shift_short(buffer) unless qos == 0
+        @payload = buffer.dup
+      end
+    end
+
+    # Class representing an MQTT Connect Packet
+    class Connect < MQTT::Packet
+      attr_accessor :protocol_name
+      attr_accessor :protocol_version
+      attr_accessor :client_id
+      attr_accessor :clean_start
+      attr_accessor :keep_alive
+      attr_accessor :will_topic
+      attr_accessor :will_qos
+      attr_accessor :will_retain
+      attr_accessor :will_payload
+
+      # Create a new Client Connect packet
+      def initialize(args={})
+        super(args)
+        self.protocol_name = args[:protocol_name] || 'MQIsdp'
+        self.protocol_version = args[:protocol_version] || 0x03
+        self.client_id = args[:client_id] || nil
+        self.clean_start = args[:clean_start] || true
+        self.keep_alive = args[:keep_alive] || 10
+        self.will_topic = args[:will_topic] || nil
+        self.will_qos = args[:will_qos] || 0
+        self.will_retain = args[:will_retain] || false
+        self.will_payload = args[:will_payload] || ''
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        body = ''
+        raise "Invalid client identifier when serialising packet" if @client_id.nil?
+        body += encode_string(@protocol_name)
+        body += encode_bytes(@protocol_version.to_i)
+        body += encode_bytes(0) # Connect Flags
+        body += encode_short(@keep_alive) # Keep Alive timer
+        body += encode_string(@client_id)
+        # FIXME: implement Will
+        #unless @will_topic.nil?
+        #  body += encode_string(@will_topic)
+        #  body += will_payload.to_s
+        #end
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a Connect packet
+      def parse_body(buffer)
+        @protocol_name = shift_string(buffer)
+        @protocol_version = shift_byte(buffer)
+        flags = shift_byte(buffer)
+        @keep_alive = shift_short(buffer)
+        @client_id = shift_string(buffer)
+        # FIXME: implement Will
+      end
+    end
+
+    # Class representing an MQTT Connect Acknowledgment Packet
+    class Connack < MQTT::Packet
+      attr_accessor :return_code
+
+      # Create a new Client Connect packet
+      def initialize(args={})
+        super(args)
+        self.return_code = args[:return_code] || 0
+      end
+    
+      # Get a string message corresponding to a return code
+      def return_msg
+        case return_code
+          when 0x00
+            "Connection Accepted"
+          when 0x01
+            "Connection refused: unacceptable protocol version"
+          when 0x02
+            "Connection refused: client identifier rejected"
+          when 0x03
+            "Connection refused: broker unavailable"
+          else
+            "Connection refused: error code #{return_code}"
+        end
+      end
+      
+      # Get serialisation of packet's body
+      def encode_body
+        body = ''
+        body += encode_bytes(0) # Unused
+        body += encode_bytes(@return_code.to_i) # Return Code
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a Connect Acknowledgment packet
+      def parse_body(buffer)
+        unused = shift_byte(buffer)
+        @return_code = shift_byte(buffer)
+      end    
+    end
+
+    # Class representing an MQTT Publish Acknowledgment packet
+    class Puback < MQTT::Packet
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        encode_short(@message_id)
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+      end
+    end
+
+    # Class representing an MQTT Publish Received packet
+    class Pubrec < MQTT::Packet
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        encode_short(@message_id)
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+      end
+    end
+
+    # Class representing an MQTT Publish Release packet
+    class Pubrel < MQTT::Packet
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        encode_short(@message_id)
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+      end
+    end
+
+    # Class representing an MQTT Publish Complete packet
+    class Pubcomp < MQTT::Packet
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        encode_short(@message_id)
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+      end
+    end
+
+    # Class representing an MQTT Client Subscribe packet
+    class Subscribe < MQTT::Packet
+      attr_reader :topics
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.topics = args[:topics] || []
+        self.message_id = args[:message_id] || 0
+        self.qos = 1 # Force a QOS of 1
+      end
+    
+      # Set one or more topics for the Subscrible packet
+      # The topics parameter should be one of the following:
+      # * String: subscribe to one topic with QOS 0
+      # * Array: subscribe to multiple topics with QOS 0
+      # * Hash: subscribe to multiple topics where the key is the topic and the value is the QOS level
+      #
+      # For example:
+      #   packet.topics = 'a/b'
+      #   packet.topics = ['a/b', 'c/d']
+      #   packet.topics = [['a/b',0], ['c/d',1]]
+      #   packet.topics = {'a/b' => 0, 'c/d' => 1}
+      #
+      def topics=(value)
+        # Get input into a consistent state
+        if value.is_a?(Array)
+          input = value.flatten
+        else
+          input = [value]
+        end
+        
+        @topics = []
+        while(input.size>0)
+          item = input.shift
+          if item.is_a?(Hash)
+            # Convert hash into an ordered array of arrays
+            @topics += item.sort
+          elsif item.is_a?(String)
+            # Peek at the next item in the array, and remove it if it is an integer
+            if input.first.is_a?(Integer)
+              qos = input.shift
+              @topics << [item,qos]
+            else
+              @topics << [item,0]
+            end
+          else
+            # Meh?
+            raise "Invalid topics input: #{value.inspect}"
+          end
+        end
+        @topics
+      end
+      
+      # Get serialisation of packet's body
+      def encode_body
+        raise "no topics given when serialising packet" if @topics.empty?
+        body = encode_short(@message_id)
+        topics.each do |item|
+          body += encode_string(item[0])
+          body += encode_bytes(item[1])
+        end
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+        @topics = []
+        while(buffer.size>0)
+          topic_name = shift_string(buffer)
+          topic_qos = shift_byte(buffer)
+          @topics << [topic_name,topic_qos]
+        end
+      end
+    end
+
+    # Class representing an MQTT Subscribe Acknowledgment packet
+    class Suback < MQTT::Packet
+      attr_accessor :message_id
+      attr_reader :granted_qos
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+        self.granted_qos = args[:granted_qos] || []
+      end
+     
+      def granted_qos=(value)
+        raise "granted QOS should be an array of arrays" unless value.is_a?(Array)
+        @granted_qos = value
+      end
+   
+      # Get serialisation of packet's body
+      def encode_body
+        raise "no granted QOS given when serialising packet" if @granted_qos.empty?
+        body = encode_short(@message_id)
+        granted_qos.flatten.each { |qos| body += encode_bytes(qos) }
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+        while(buffer.size>0)
+          @granted_qos << [shift_byte(buffer),shift_byte(buffer)]
+        end
+      end
+    end
+
+    # Class representing an MQTT Client Unsubscribe packet
+    class Unsubscribe < MQTT::Packet
+      attr_reader :topics
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.topics = args[:topics] || []
+        self.message_id = args[:message_id] || 0
+        self.qos = 1 # Force a QOS of 1
+      end
+    
+      def topics=(value)
+        if value.is_a?(Array)
+          @topics = value
+        else
+          @topics = [value]
+        end
+      end
+      
+      # Get serialisation of packet's body
+      def encode_body
+        raise "no topics given when serialising packet" if @topics.empty?
+        body = encode_short(@message_id)
+        topics.each { |topic| body += encode_string(topic) }
+        return body
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+        while(buffer.size>0)
+          @topics << shift_string(buffer)
+        end
+      end
+    end
+
+    # Class representing an MQTT Unsubscribe Acknowledgment packet
+    class Unsuback < MQTT::Packet
+      attr_accessor :message_id
+  
+      # Create a new Unsubscribe Acknowledgment packet
+      def initialize(args={})
+        super(args)
+        self.message_id = args[:message_id] || 0
+      end
+    
+      # Get serialisation of packet's body
+      def encode_body
+        encode_short(@message_id)
+      end
+      
+      # Parse the body (variable header and payload) of a packet
+      def parse_body(buffer)
+        @message_id = shift_short(buffer)
+      end
+    end
+
+    # Class representing an MQTT Ping Request packet
+    class Pingreq < MQTT::Packet
+      # Create a new Ping Request packet
+      def initialize(args={})
+        super(args)
+      end
+    end
+
+    # Class representing an MQTT Ping Response packet
+    class Pingresp < MQTT::Packet
+      # Create a new Ping Response packet
+      def initialize(args={})
+        super(args)
+      end
+    end
+
+    # Class representing an MQTT Client Disconnect packet
+    class Disconnect < MQTT::Packet
+      # Create a new Client Disconnect packet
+      def initialize(args={})
+        super(args)
+      end
+    end
     
   end
+
+
+  # An enumeration of the MQTT packet types
+  PACKET_TYPES = [
+    nil,
+    MQTT::Packet::Connect,
+    MQTT::Packet::Connack,
+    MQTT::Packet::Publish,
+    MQTT::Packet::Puback,
+    MQTT::Packet::Pubrec,
+    MQTT::Packet::Pubrel,
+    MQTT::Packet::Pubcomp,
+    MQTT::Packet::Subscribe,
+    MQTT::Packet::Suback,
+    MQTT::Packet::Unsubscribe,
+    MQTT::Packet::Unsuback,
+    MQTT::Packet::Pingreq,
+    MQTT::Packet::Pingresp,
+    MQTT::Packet::Disconnect,
+    nil
+  ]
   
 end

data/lib/mqtt/proxy.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+require 'mqtt'
+require 'mqtt/packet'
+require 'thread'
+require 'logger'
+require 'socket'
+
+
+module MQTT
+
+  # Class for implementing a proxy to filter/mangle MQTT packets.
+  class Proxy
+    attr_reader :local_host
+    attr_reader :local_port
+    attr_reader :broker_host
+    attr_reader :broker_port
+    attr_reader :listen_queue
+    attr_reader :select_timeout
+    attr_reader :logger
+  
+    # Create a new MQTT Proxy instance.
+    #
+    # Possible argument keys:
+    #
+    #  :local_host      Address to bind listening socket to.
+    #  :local_port      Port to bind listening socket to.
+    #  :broker_host     Address of upstream broker to send packets upstream to.
+    #  :broker_port     Port of upstream broker to send packets upstream to.
+    #  :select_timeout  Time in seconds before disconnecting a connection.
+    #  :logger          Ruby Logger object to send informational messages to.
+    #
+    # NOTE: be careful not to connect to yourself!
+    def initialize(args={})
+      @local_host = args[:local_host] || '0.0.0.0'
+      @local_port = args[:local_port] || 1883
+      @broker_host = args[:broker_host] || 'localhost'
+      @broker_port = args[:broker_port] || 18830
+      @select_timeout = args[:select_timeout] || 60
+      
+      # Setup a logger
+      @logger = args[:logger]
+      if @logger.nil?
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::INFO
+      end
+      
+      # Default is not to have any filters
+      @client_filter = nil
+      @broker_filter = nil
+      
+      # Create TCP server socket
+      @server = TCPServer.open(@local_host,@local_port)
+      @logger.info "MQTT::Proxy listening on #{@local_host}:#{@local_port}"
+    end
+    
+    # Set a filter Proc for packets coming from the client (to the broker).
+    def client_filter=(proc)
+      @client_filter = proc
+    end
+    
+    # Set a filter Proc for packets coming from the broker (to the client).
+    def broker_filter=(proc)
+      @broker_filter = proc
+    end
+    
+    # Start accepting connections and processing packets.
+    def run
+      loop do
+        # Wait for a client to connect and then create a thread for it
+        Thread.new(@server.accept) do |client_socket|
+          logger.info "Accepted client: #{client_socket.peeraddr.join(':')}"
+          broker_socket = TCPSocket.new(@broker_host,@broker_port)
+          begin
+            process_packets(client_socket,broker_socket)
+          rescue Exception => exp
+            logger.error exp.to_s
+          end
+          logger.info "Disconnected: #{client_socket.peeraddr.join(':')}"
+          broker_socket.close
+          client_socket.close
+        end
+      end
+    end
+
+    private
+    
+    def process_packets(client_socket,broker_socket)
+      loop do
+        # Wait for some data on either socket
+        selected = IO.select([client_socket,broker_socket], nil, nil, @select_timeout)
+        if selected.nil?
+          # Timeout
+          raise "Timeout in select"
+        else
+          # Iterate through each of the sockets with data to read
+          if selected[0].include?(client_socket)
+            packet = MQTT::Packet.read(client_socket)
+            logger.debug "client -> <#{packet.type}>"
+            packet = @client_filter.call(packet) unless @client_filter.nil?
+            unless packet.nil?
+              broker_socket.write(packet)
+              logger.debug "<#{packet.type}> -> broker"
+            end
+          elsif selected[0].include?(broker_socket)
+            packet = MQTT::Packet.read(broker_socket)
+            logger.debug "broker -> <#{packet.type}>"
+            packet = @broker_filter.call(packet) unless @broker_filter.nil?
+            unless packet.nil?
+              client_socket.write(packet)
+              logger.debug "<#{packet.type}> -> client"
+            end
+          else
+            logger.error "Problem with select: socket is neither broker or client"
+          end
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mqtt
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Nicholas J Humfrey
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-08 00:00:00 +00:00
+date: 2009-02-22 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -28,7 +28,9 @@ files:
 - lib/mqtt.rb
 - lib/mqtt/client.rb
 - lib/mqtt/packet.rb
+- lib/mqtt/proxy.rb
 - examples/livetext.rb
+- examples/readonly_proxy.rb
 - examples/simple_get.rb
 - examples/simple_publish.rb
 - README