diameter 0.1.0.beta

data/lib/diameter/message.rb

@@ -0,0 +1,267 @@
+require 'diameter/avp_parser'
+require 'diameter/u24'
+
+# The Diameter module
+module Diameter
+  # A Diameter message.
+  #
+  # @!attribute [r] version
+  #   The Diameter protocol version (currently always 1)
+  # @!attribute [r] command_code
+  #   The Diameter Command-Code of this messsage.
+  # @!attribute [r] app_id
+  #   The Diameter application ID of this message, or 0 for base
+  #   protocol messages.
+  # @!attribute [r] hbh
+  #   The hop-by-hop identifier of this message.
+  # @!attribute [r] ete
+  #   The end-to-end identifier of this message.
+  # @!attribute [r] request
+  #   Whether this message is a request.
+  # @!attribute [r] answer
+  #   Whether this message is an answer.
+  class Message
+    attr_reader :version, :command_code, :app_id, :hbh, :ete, :request, :answer
+    include Internals
+
+    # Creates a new Diameter message.
+    #
+    # @option opts [Fixnum] command_code
+    #   The Diameter Command-Code of this messsage.
+    # @option opts [Fixnum] app_id
+    #   The Diameter application ID of this message, or 0 for base
+    #   protocol messages.
+    # @option opts [Fixnum] hbh
+    #   The hop-by-hop identifier of this message.
+    # @option opts [Fixnum] ete
+    #   The end-to-end identifier of this message.
+    # @option opts [true, false] request
+    #   Whether this message is a request. Defaults to true.
+    # @option opts [true, false] proxyable
+    #   Whether this message can be forwarded on. Defaults to true.
+    # @option opts [true, false] error
+    #   Whether this message is a Diameter protocol error. Defaults to false.
+    # @option opts [Array<AVP>] avps
+    #   The list of AVPs to include on this message.
+    def initialize(options = {})
+      @version = 1
+      @command_code = options[:command_code]
+      @app_id = options[:app_id]
+      @hbh = options[:hbh] || Message.next_hbh
+      @ete = options[:ete] || Message.next_ete
+
+      @request = options.fetch(:request, true)
+      @answer = !@request
+      @proxyable = options.fetch(:proxyable, false)
+      @retransmitted = false
+      @error = false
+
+      @avps = options[:avps] || []
+    end
+
+    # Represents this message (and all its AVPs) in human-readable
+    # string form.
+    #
+    # @see AVP::to_s for how the AVPs are represented.
+    # @return [String]
+    def to_s
+      "#{@command_code}: #{@avps.collect(&:to_s)}"
+    end
+
+    # Serializes a Diameter message (header plus AVPs) into the series
+    # of bytes representing it on the wire.
+    #
+    # @return [String] The byte-encoded form.
+    def to_wire
+      content = ''
+      @avps.each { |a| content += a.to_wire }
+      length_8, length_16 = Internals::UInt24.to_u8_and_u16(content.length + 20)
+      code_8, code_16 = Internals::UInt24.to_u8_and_u16(@command_code)
+      request_flag = @request ? '1' : '0'
+      proxy_flag = @proxyable ? '1' : '0'
+      flags_str = "#{request_flag}#{proxy_flag}000000"
+
+      header = [@version, length_8, length_16, flags_str, code_8, code_16, @app_id, @hbh, @ete].pack('CCnB8CnNNN')
+      header + content
+    end
+
+    # @!group AVP retrieval
+
+    # Returns the first AVP with the given name. Only covers "top-level"
+    # AVPs - it won't look inside Grouped AVPs.
+    #
+    # Also available as [], e.g. message['Result-Code']
+    #
+    # @param name [String] The AVP name, either one predefined in
+    #   {Constants::AVAILABLE_AVPS} or user-defined with {AVP.define}
+    #
+    # @return [AVP] if there is an AVP with that name
+    # @return [nil] if there is not an AVP with that name
+    def avp_by_name(name)
+      code, _type, vendor = Internals::AVPNames.get(name)
+      avp_by_code(code, vendor)
+    end
+
+    # Returns all AVPs with the given name. Only covers "top-level"
+    # AVPs - it won't look inside Grouped AVPs.
+    #
+    # @param name [String] The AVP name, either one predefined in
+    #   {Constants::AVAILABLE_AVPS} or user-defined with {AVP.define}
+    #
+    # @return [Array<AVP>]
+    def all_avps_by_name(name)
+      code, _type, vendor = Internals::AVPNames.get(name)
+      all_avps_by_code(code, vendor)
+    end
+
+    alias_method :avp, :avp_by_name
+    alias_method :[], :avp_by_name
+    alias_method :avps, :all_avps_by_name
+
+    # @private
+    # Prefer AVP.define and the by-name versions to this
+    #
+    # Returns the first AVP with the given code and vendor. Only covers "top-level"
+    # AVPs - it won't look inside Grouped AVPs.
+    #
+    # @param code [Fixnum] The AVP Code
+    # @param vendor [Fixnum] Optional vendor ID for a vendor-specific
+    #   AVP.
+    # @return [AVP] if there is an AVP with that code/vendor
+    # @return [nil] if there is not an AVP with that code/vendor
+    def avp_by_code(code, vendor = 0)
+      avps = all_avps_by_code(code, vendor)
+      if avps.empty?
+        nil
+      else
+        avps[0]
+      end
+    end
+
+    # @private
+    # Prefer AVP.define and the by-name versions to this
+    #
+    # Returns all AVPs with the given code and vendor. Only covers "top-level"
+    # AVPs - it won't look inside Grouped AVPs.
+    #
+    # @param code [Fixnum] The AVP Code
+    # @param vendor [Fixnum] Optional vendor ID for a vendor-specific
+    #   AVP.
+    # @return [Array<AVP>]
+    def all_avps_by_code(code, vendor = 0)
+      @avps.select do |a|
+        vendor_match =
+          if a.vendor_specific?
+            a.vendor_id == vendor
+          else
+            vendor == 0
+          end
+        (a.code == code) && vendor_match
+      end
+    end
+
+    # Does this message contain a (top-level) AVP with this name?
+    # @param name [String] The AVP name, either one predefined in
+    #   {Constants::AVAILABLE_AVPS} or user-defined with {AVP.define}
+    #
+    # @return [true, false]  
+    def has_avp?(name)
+      !!avp(name)
+    end
+
+    # @private
+    #
+    # Not recommended for normal use - all AVPs should be given to the
+    # constructor. Used to allow the stack to add appropriate
+    # Origin-Host/Origin-Realm AVPs to outbound messages.
+    #
+    # @param host [String] The Diameter Identity for the stack.
+    # @param realm [String] The Diameter realm for the stack.
+    def add_origin_host_and_realm(host, realm)
+      @avps << AVP.create("Origin-Host", host) unless has_avp? 'Origin-Host'
+      @avps << AVP.create("Origin-Realm", realm) unless has_avp? 'Origin-Realm'
+    end
+    
+    # @!endgroup
+
+    # @!group Parsing
+    
+    # Parses the first four bytes of the Diameter header to learn the
+    # length. Callers should use this to work out how many more bytes
+    # they need to read off a TCP connection to pass to self.from_bytes.
+    #
+    # @param header [String] A four-byte Diameter header
+    # @return [Fixnum] The message length field from the header
+    def self.length_from_header(header)
+      _version, length_8, length_16 = header.unpack('CCn')
+      Internals::UInt24.from_u8_and_u16(length_8, length_16)
+    end
+
+    # Parses a byte representation (a 20-byte header plus AVPs) into a
+    # DiameterMessage object.
+    #
+    # @param bytes [String] The on-the-wire byte representation of a
+    #   Diameter message.
+    # @return [DiameterMessage] The parsed object form.
+    def self.from_bytes(bytes)
+      header = bytes[0..20]
+      version, _length_8, _length_16, flags_str, code_8, code_16, app_id, hbh, ete = header.unpack('CCnB8CnNNN')
+      command_code = Internals::UInt24.from_u8_and_u16(code_8, code_16)
+
+      request = (flags_str[0] == '1')
+      proxyable = (flags_str[1] == '1')
+
+      avps = Internals::AVPParser.parse_avps_int(bytes[20..-1])
+      Message.new(version: version, command_code: command_code, app_id: app_id, hbh: hbh, ete: ete, request: request, proxyable: proxyable, retransmitted: false, error: false, avps: avps)
+    end
+    
+    # @!endgroup
+
+    # Generates an answer to this request, filling in a Result-Code or
+    # Experimental-Result AVP.
+    #
+    # @param result_code [Fixnum] The value for the Result-Code AVP
+    # @option opts [Fixnum] experimental_result_vendor
+    #   If given, creates an Experimental-Result AVP with this vendor
+    #   instead of the Result-Code AVP. 
+    # @option opts [Array<String>] copying_avps
+    #   A list of AVP names to copy from the request to the answer.
+    # @option opts [Array<Diameter::AVP>] avps
+    #   A list of AVP objects to add on the answer.
+    # @return [Diameter::Message] The response created.
+    def create_answer(result_code, opts={})
+      fail "Cannot answer an answer" if answer
+      
+      avps = opts.fetch(:avps, [])
+      avps << if opts[:experimental_result_vendor]
+                fail
+              else
+                AVP.create("Result-Code", result_code)
+              end
+      
+      avps += opts.fetch(:copying_avps, []).collect do |name|
+        src_avp = avp_by_name(name)
+
+        fail if src_avp.nil?
+        
+        src_avp.dup
+      end
+
+      Message.new(version: version, command_code: command_code, app_id: app_id, hbh: hbh, ete: ete, request: false, proxyable: @proxyable, retransmitted: false, error: false, avps: avps)
+    end
+
+    private
+    def self.next_hbh
+      @hbh ||= rand(10000)
+      @hbh += 1
+      @hbh
+    end
+
+    def self.next_ete
+      @ete ||= (Time.now.to_i & 0x00000fff) + (rand(2**32) & 0xfffff000)
+      @ete += 1
+      @ete
+    end
+
+  end
+end

data/lib/diameter/peer.rb

@@ -0,0 +1,59 @@
+require 'diameter/diameter_logger'
+
+module Diameter
+  # A Diameter peer entry in the peer table.
+  #
+  # @!attribute [rw] identity
+  #   [String] The DiameterIdentity of this peer
+  # @!attribute [rw] realm
+  #   [String] The Diameter realm of this peer
+  # @!attribute [rw] static
+  #   [true, false] Whether this peer was dynamically discovered (and so
+  #   might expire) or statically configured.
+  # @!attribute [rw] expiry_time
+  #   [Time] For a dynamically discovered peer, the time when it stops
+  #   being valid and dynamic discovery must happen again.
+  # @!attribute [rw] last_message_seen
+  #   [Time] The last time traffic was received from this peer. Used for
+  #   determining when to send watchdog messages, or for triggering failover.
+  # @!attribute [rw] cxn
+  #   [Socket] The underlying network connection to this peer.
+  # @!attribute [rw] state
+  #   [Keyword] The current state of this peer - :UP, :WATING or :CLOSED.
+
+  class Peer
+    attr_accessor :identity, :static, :cxn, :realm, :expiry_time, :last_message_seen
+    attr_reader :state
+
+    def initialize(identity)
+      @identity = identity
+      @state = :CLOSED
+      @state_change_q = Queue.new
+    end
+
+    # Blocks until the state of this peer changes to the desired value.
+    #
+    # @param state [Keyword] The state to change to.
+    def wait_for_state_change(state)
+      cur_state = @state
+      while (cur_state != state)
+        cur_state = @state_change_q.pop
+      end
+    end
+
+    # @todo Add further checking, making sure that the transition to
+    # new_state is valid according to the RFC 6733 state machine. Maybe
+    # use the micromachine gem?
+    def state=(new_state)
+      Diameter.logger.log(Logger::DEBUG, "State of peer #{identity} changed from #{@state} to #{new_state}")
+      @state = new_state
+      @state_change_q.push new_state
+    end
+
+    # Resets the last message seen time. Should be called when a message
+    # is received from this peer.
+    def reset_timer
+      self.last_message_seen = Time.now
+    end
+  end
+end

data/lib/diameter/stack.rb

@@ -0,0 +1,359 @@
+require 'uri'
+require 'socket'
+require 'diameter/peer'
+require 'diameter/message'
+require 'diameter/stack_transport_helpers'
+require 'diameter/diameter_logger'
+require 'concurrent'
+
+module Diameter
+  class Stack
+    include Internals
+
+    # @!group Setup methods
+
+    # Stack constructor.
+    #
+    # @note The stack does not advertise any applications to peers by
+    #  default - {#add_handler} must be called early on.
+    #
+    # @param host [String] The Diameter Identity of this stack (for
+    #  the Origin-Host AVP).
+    # @param realm [String] The Diameter realm of this stack (for
+    #  the Origin-Realm AVP).
+    def initialize(host, realm)
+      @local_host = host
+      @local_realm = realm
+
+      @auth_apps = []
+      @acct_apps = []
+
+      @pending_ete = {}
+
+      @tcp_helper = TCPStackHelper.new(self)
+      @peer_table = {}
+      @handlers = {}
+
+      @threadpool = pool = Concurrent::ThreadPoolExecutor.new(
+                                                              min_threads: 5,
+                                                              max_threads: 5,
+                                                              max_queue: 100,
+                                                              overflow_policy: :caller_runs
+                                                              )
+
+      
+      Diameter.logger.log(Logger::INFO, 'Stack initialized')
+    end
+
+    # Complete the stack initialization and begin reading from the TCP connections.
+    def start
+      @tcp_helper.start_main_loop
+    end
+
+    # Begins listening for inbound Diameter connections (making this a
+    # Diameter server instead of just a client).
+    #
+    # @param port [Fixnum] The TCP port to listen on (default 3868)
+    def listen_for_tcp(port=3868)
+      @tcp_helper.setup_new_listen_connection("0.0.0.0", port)
+    end
+
+    # Adds a handler for a specific Diameter application.
+    #
+    # @note If you expect to only send requests for this application,
+    #  not receive them, the block can be a no-op (e.g. `{ nil }`)
+    #
+    # @param app_id [Fixnum] The Diameter application ID.
+    # @option opts [true, false] auth
+    #   Whether we should advertise support for this application in
+    #   the Auth-Application-ID AVP. Note that at least one of auth or
+    #   acct must be specified.
+    # @option opts [true, false] acct
+    #   Whether we should advertise support for this application in
+    #   the Acct-Application-ID AVP. Note that at least one of auth or
+    #   acct must be specified.
+    # @option opts [Fixnum] vendor
+    #  If we should advertise support for this application in a
+    #  Vendor-Specific-Application-Id AVP, this specifies the
+    #  associated Vendor-Id.
+    #
+    # @yield [req, cxn] Passes a Diameter message (and its originating
+    #  connection) for application-specific handling.
+    # @yieldparam [Message] req The parsed Diameter message from the peer.
+    # @yieldparam [Socket] cxn The TCP connection to the peer, to be
+    #  passed to {Stack#send_answer}.
+    def add_handler(app_id, opts={}, &blk)
+      vendor = opts.fetch(:vendor, 0)
+      auth = opts.fetch(:auth, false)
+      acct = opts.fetch(:acct, false)
+
+      raise ArgumentError.new("Must specify at least one of auth or acct") unless auth or acct
+      
+      @acct_apps << [app_id, vendor] if acct
+      @auth_apps << [app_id, vendor] if auth
+      
+      @handlers[app_id] = blk
+    end
+
+    # @!endgroup
+
+    # This shuts the stack down, closing all TCP connections and
+    # terminating any background threads still waiting for an answer.
+    def shutdown
+      @tcp_helper.shutdown
+      @pending_ete.each do |ete, q|
+        Diameter.logger.debug("Shutting down queue #{q} as no answer has been received with EtE #{ete}")
+        q.push :shutdown
+      end
+      @threadpool.kill
+      @threadpool.wait_for_termination(5)
+    end
+
+    # Closes the given connection, blanking out any internal data
+    # structures associated with it.
+    #
+    # Likely to be moved to the Peer object in a future release/
+    #
+    # @param connection [Socket] The connection to close.
+    def close(connection)
+      @tcp_helper.close(connection)
+    end
+    
+    # @!group Peer connections and message sending
+    
+    # Creates a Peer connection to a Diameter agent at the specific
+    # network location indicated by peer_uri.
+    #
+    # @param peer_uri [URI] The aaa:// URI identifying the peer. Should
+    #   contain a hostname/IP; may contain a port (default 3868).
+    # @param peer_host [String] The DiameterIdentity of this peer, which
+    #   will uniquely identify it in the peer table.
+    # @param realm [String] The Diameter realm of this peer.
+    def connect_to_peer(peer_uri, peer_host, realm)
+      uri = URI(peer_uri)
+      cxn = @tcp_helper.setup_new_connection(uri.host, uri.port)
+      avps = [AVP.create('Origin-Host', @local_host),
+              AVP.create('Origin-Realm', @local_realm),
+              AVP.create('Host-IP-Address', IPAddr.new('127.0.0.1')),
+              AVP.create('Vendor-Id', 100),
+              AVP.create('Product-Name', 'ruby-diameter')
+             ]
+      avps += app_avps
+      cer_bytes = Message.new(version: 1, command_code: 257, app_id: 0, request: true, proxyable: false, retransmitted: false, error: false, avps: avps).to_wire
+      @tcp_helper.send(cer_bytes, cxn)
+      @peer_table[peer_host] = Peer.new(peer_host)
+      @peer_table[peer_host].state = :WAITING
+      @peer_table[peer_host].cxn = cxn
+      @peer_table[peer_host]
+      # Will move to :UP when the CEA is received
+    end
+
+    # Sends a Diameter request. This is routed to an appropriate peer
+    # based on the Destination-Host AVP.
+    #
+    # This adds this stack's Origin-Host and Origin-Realm AVPs, if
+    # those AVPs don't already exist.
+    #
+    # @param req [Message] The request to send.
+    def send_request(req)
+      fail "Must pass a request" unless req.request
+      req.add_origin_host_and_realm(@local_host, @local_realm) 
+      peer_name = req.avp_by_name('Destination-Host').octet_string
+      state = peer_state(peer_name)
+      if state == :UP
+        peer = @peer_table[peer_name]
+        @tcp_helper.send(req.to_wire, peer.cxn)
+        q = Queue.new
+        @pending_ete[req.ete] = q
+        p = Concurrent::Promise.execute(executor: @threadpool) {
+          Diameter.logger.debug("Waiting for answer to message with EtE #{req.ete}, queue #{q}")
+          val = q.pop
+          Diameter.logger.debug("Promise fulfilled for message with EtE #{req.ete}")
+          val
+        }
+        return p
+      else
+        Diameter.logger.log(Logger::WARN, "Peer #{peer_name} is in state #{state} - cannot route")
+      end
+    end
+
+    # Sends a Diameter answer. This is sent over the same connection
+    # the request was received on (which needs to be passed into to
+    # this method).
+    #
+    # This adds this stack's Origin-Host and Origin-Realm AVPs, if
+    # those AVPs don't already exist.
+    #
+    # @param ans [Message] The Diameter answer
+    # @param original_cxn [Socket] The connection which the request
+    #   came in on. This will have been passed to the block registered
+    #   with {Stack#add_handler}.
+    def send_answer(ans, original_cxn)
+      fail "Must pass an answer" unless ans.answer
+      ans.add_origin_host_and_realm(@local_host, @local_realm) 
+      @tcp_helper.send(ans.to_wire, original_cxn)
+    end
+
+    # Retrieves the current state of a peer, defaulting to :CLOSED if
+    # the peer does not exist.
+    #
+    # @param id [String] The Diameter identity of the peer.
+    # @return [Keyword] The state of the peer (:UP, :WAITING or :CLOSED).
+    def peer_state(id)
+      if !@peer_table.key? id
+        :CLOSED
+      else
+        @peer_table[id].state
+      end
+    end
+
+    # @!endgroup
+    
+    # @private
+    # Handles a Diameter request straight from a network connection.
+    # Intended to be called by TCPStackHelper after it retrieves a
+    # message, not directly by users.
+    def handle_message(msg_bytes, cxn)
+      # Common processing - ensure that this message has come in on this
+      # peer's expected connection, and update the last time we saw
+      # activity on this peer
+      msg = Message.from_bytes(msg_bytes)
+      Diameter.logger.debug("Handling message #{msg}")
+      peer = msg.avp_by_name('Origin-Host').octet_string
+      if @peer_table[peer]
+        @peer_table[peer].reset_timer
+        unless @peer_table[peer].cxn == cxn
+          Diameter.logger.log(Logger::WARN, "Ignoring message - claims to be from #{peer} but comes from #{cxn} not #{@peer_table[peer].cxn}")
+        end
+      end
+
+      if msg.command_code == 257 && msg.answer
+        handle_cea(msg)
+      elsif msg.command_code == 257 && msg.request
+        handle_cer(msg, cxn)
+      elsif msg.command_code == 280 && msg.request
+        handle_dwr(msg, cxn)
+      elsif msg.command_code == 280 && msg.answer
+        # No-op - we've already updated our timestamp
+      elsif msg.answer
+        handle_other_answer(msg, cxn)
+      elsif @handlers.has_key? msg.app_id
+        @handlers[msg.app_id].call(msg, cxn)
+      else
+        fail "Received unknown message of type #{msg.command_code}"
+      end
+    end
+
+    private
+
+    def app_avps
+      avps = []
+      
+      @auth_apps.each do |app_id, vendor|
+        avps << if vendor == 0
+                  AVP.create("Auth-Application-Id", app_id)
+                else
+                  AVP.create("Vendor-Specific-Application-Id",
+                             [AVP.create("Auth-Application-Id", app_id),
+                              AVP.create("Vendor-Id", vendor)])
+                end
+      end
+
+      @acct_apps.each do |app_id, vendor|
+        avps << if vendor == 0
+                  AVP.create("Acct-Application-Id", app_id)
+                else
+                  AVP.create("Vendor-Specific-Application-Id",
+                             [AVP.create("Acct-Application-Id", app_id),
+                              AVP.create("Vendor-Id", vendor)])
+                end
+      end
+      
+      avps
+    end
+
+    def shared_apps(capabilities_msg)
+      peer_apps = capabilities_msg.all_avps_by_name("Auth-Application-Id").collect(&:uint32)
+      peer_apps += capabilities_msg.all_avps_by_name("Acct-Application-Id").collect(&:uint32)
+
+      capabilities_msg.all_avps_by_name("Vendor-Specific-Application-Id").each do |avp|
+        if avp.inner_avp("Auth-Application-Id")
+          peer_apps << avp.inner_avp("Auth-Application-Id").uint32
+        end
+
+        if avp.inner_avp("Acct-Application-Id")
+          peer_apps << avp.inner_avp("Acct-Application-Id").uint32
+        end
+      end
+
+      Diameter.logger.debug("Received app IDs #{peer_apps} from peer, have apps #{@handlers.keys}")
+      
+      @handlers.keys.to_set & peer_apps.to_set
+    end    
+    
+    def handle_cer(cer, cxn)
+      if shared_apps(cer).empty?
+        rc = 5010
+      else
+        rc = 2001
+      end
+      
+      cea = cer.create_answer(rc, avps:
+                              [AVP.create('Origin-Host', @local_host),
+                               AVP.create('Origin-Realm', @local_realm)] + app_avps)
+
+      @tcp_helper.send(cea.to_wire, cxn)
+
+      if rc == 2001
+        peer = cer.avp_by_name('Origin-Host').octet_string
+        Diameter.logger.debug("Creating peer table entry for peer #{peer}")
+        @peer_table[peer] = Peer.new(peer)
+        @peer_table[peer].state = :UP
+        @peer_table[peer].reset_timer
+        @peer_table[peer].cxn = cxn
+      else
+        @tcp_helper.close(cxn)
+      end
+    end
+
+    def handle_cea(cea)
+      peer = cea.avp_by_name('Origin-Host').octet_string
+      if @peer_table.has_key? peer
+        @peer_table[peer].state = :UP
+        @peer_table[peer].reset_timer
+      else
+        Diameter.logger.warn("Ignoring CEA from unknown peer #{peer}")
+        Diameter.logger.debug("Known peers are #{@peer_table.keys}")
+      end
+    end
+
+    def handle_dpr
+    end
+
+    def handle_dpa
+    end
+
+    def handle_dwr(dwr, cxn)
+      dwa = dwr.create_answer(2001, avps:
+                              [AVP.create('Origin-Host', @local_host),
+                               AVP.create('Origin-Realm', @local_realm)])
+
+      @tcp_helper.send(dwa.to_wire, cxn)
+      # send DWA
+    end
+
+    def handle_dwa
+    end
+
+    def handle_other_request
+    end
+
+    def handle_other_answer(msg, _cxn)
+      Diameter.logger.debug("Handling answer with End-to-End identifier #{msg.ete}")
+      q = @pending_ete[msg.ete]
+      q.push msg
+      Diameter.logger.debug("Passed answer to fulfil sender's Promise object'")
+      @pending_ete.delete msg.ete
+    end
+  end
+end