qpid_proton 0.19.0 → 0.21.0

data/tests/test_interop.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+require 'test_tools'
+require 'qpid_proton'
+
+if ((RUBY_VERSION.split(".").map {|x| x.to_i}  <=> [1, 9]) < 0)
+  require 'pathname'
+  class File
+    def self.absolute_path(name)
+      return Pathname.new(name).realpath
+    end
+  end
+end
+
+class InteropTest < MiniTest::Test
+  include  Qpid::Proton
+
+  def setup
+    @data = Codec::Data.new
+    @message = Message.new
+  end
+
+  # Walk up the directory tree to find the tests directory.
+  def get_data(name)
+    path = File.join(File.dirname(__FILE__), "../../../../tests/interop/#{name}.amqp")
+    raise "Can't find test/interop directory from #{__FILE__}" unless File.exists?(path)
+    File.open(path, "rb") { |f| f.read }
+  end
+
+  # Decode encoded bytes as a Data object
+  def decode_data(encoded)
+    buffer = encoded
+    while buffer.size > 0
+      n = @data.decode(buffer)
+      buffer = buffer[n..-1]
+    end
+    @data.rewind
+    reencoded = @data.encode
+    # Test the round-trip re-encoding gives the same result.
+    assert_equal(encoded, reencoded)
+  end
+
+  def decode_data_file(name) decode_data(get_data(name)); end
+
+  def decode_message_file(name)
+    message = Message.new()
+    message.decode(self.get_data(name))
+    self.decode_data(message.body)
+  end
+
+  def assert_next(type, value)
+    assert @data.next
+    assert_equal(type, @data.type)
+    assert_equal(value, @data.object)
+  end
+
+  def assert_array_next(expected)
+    result = @data.next_object
+    assert_equal(expected, result)
+  end
+
+  def test_message
+    decode_message_file("message")
+    assert_next(Codec::STRING, "hello")
+    assert !@data.next
+  end
+
+  def test_primitives
+    decode_data_file("primitives")
+    assert_next(Codec::BOOL, true)
+    assert_next(Codec::BOOL, false)
+    assert_next(Codec::UBYTE, 42)
+    assert_next(Codec::USHORT, 42)
+    assert_next(Codec::SHORT, -42)
+    assert_next(Codec::UINT, 12345)
+    assert_next(Codec::INT, -12345)
+    assert_next(Codec::ULONG, 12345)
+    assert_next(Codec::LONG, -12345)
+    assert_next(Codec::FLOAT, 0.125)
+    assert_next(Codec::DOUBLE, 0.125)
+    assert !@data.next
+  end
+
+  def test_strings
+    decode_data_file("strings")
+    assert_next(Codec::BINARY, "abc\0defg")
+    assert_next(Codec::STRING, "abcdefg")
+    assert_next(Codec::SYMBOL, :abcdefg)
+    assert_next(Codec::BINARY, "")
+    assert_next(Codec::STRING, "")
+    assert_next(Codec::SYMBOL, :"")
+    assert !@data.next
+  end
+
+  def test_described
+    decode_data_file("described")
+    assert_next(Codec::DESCRIBED, Types::Described.new(:"foo-descriptor", "foo-value"))
+    assert(@data.described?)
+    assert_next(Codec::DESCRIBED, Types::Described.new(12, 13))
+    assert(@data.described?)
+    assert !@data.next
+  end
+
+  def test_described_array
+    decode_data_file("described_array")
+    assert_array_next(Types::UniformArray.new(Types::INT, (0...10).to_a, :"int-array"))
+  end
+
+  def test_arrays
+    decode_data_file("arrays")
+    assert_array_next(Types::UniformArray.new(Codec::INT, (0...100).to_a))
+    assert_array_next(Types::UniformArray.new(Codec::STRING, ["a", "b", "c"]))
+    assert_array_next(Types::UniformArray.new(Codec::INT))
+    assert !@data.next
+  end
+
+  def test_lists
+    decode_data_file("lists")
+    assert_next(Codec::LIST, [32, "foo", true])
+    assert_next(Codec::LIST, [])
+    assert !@data.next
+  end
+
+  def test_maps
+    decode_data_file("maps")
+    assert_next(Codec::MAP, {"one" => 1, "two" => 2, "three" => 3 })
+    assert_next(Codec::MAP, {1 => "one", 2 => "two", 3 => "three"})
+    assert_next(Codec::MAP, {})
+    assert !@data.next
+  end
+end

data/tests/test_messaging_adapter.rb

@@ -0,0 +1,223 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+require 'minitest/autorun'
+require 'qpid_proton'
+require 'test_tools'
+include Qpid::Proton
+
+# Records every call, never provokes "on_unhandled"
+class RecordingHandler < Qpid::Proton::MessagingHandler
+
+  def initialize(*args) super(*args); @calls = []; end
+
+  attr_accessor :calls
+
+  def names() @calls.collect { |c| c[0] }; end
+
+  def clear() @calls.clear; end
+
+  def method_missing(name, *args)
+    respond_to_missing?(name) ? (@calls << [name, *args]) : super;
+  end
+  def respond_to_missing?(name, private=false); (/^on_/ =~ name); end
+  def respond_to?(name, all=false) super || respond_to_missing?(name); end # For ruby < 1.9.2
+end
+
+class NoAutoOpenClose < RecordingHandler
+  def initialize() super; @endpoints = []; end
+  def on_connection_open(x) @connection = x; super; raise StopAutoResponse; end
+  def on_session_open(x) @session = x; super; raise StopAutoResponse; end
+  def on_sender_open(x) @link = x; super; raise StopAutoResponse; end
+  def on_receiver_open(x) @link = x; super; raise StopAutoResponse; end
+  def on_connection_close(x) super; raise StopAutoResponse; end
+  def on_session_close(x) super; raise StopAutoResponse; end
+  def on_sender_close(x) super; raise StopAutoResponse; end
+  def on_receiver_close(x) super; raise StopAutoResponse; end
+  attr_reader :connection, :session, :link
+end
+
+class TestMessagingHandler < MiniTest::Test
+
+  def test_auto_open_close
+    d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
+    d.client.connection.open; d.client.connection.open_sender; d.run
+    assert_equal [:on_connection_open, :on_session_open, :on_sender_open, :on_sendable], d.client.handler.names
+    assert_equal [:on_connection_open, :on_session_open, :on_receiver_open], d.server.handler.names
+    d.clear
+    d.client.connection.close; d.run
+    assert_equal [:on_connection_close, :on_transport_close], d.server.handler.names
+    assert_equal [:on_connection_close, :on_transport_close], d.client.handler.names
+  end
+
+  def test_no_auto_open_close
+    d = DriverPair.new(NoAutoOpenClose.new, NoAutoOpenClose.new)
+    d.client.connection.open; d.run
+    assert_equal [:on_connection_open], d.server.handler.names
+    assert_equal [], d.client.handler.names
+    d.server.connection.open; d.run
+    assert_equal [:on_connection_open], d.client.handler.names
+    assert_equal [:on_connection_open], d.server.handler.names
+    d.clear
+    d.client.connection.open_session; d.run
+    assert_equal [:on_session_open], d.server.handler.names
+    assert_equal [], d.client.handler.names
+    d.clear
+    d.client.connection.close;
+    3.times { d.process }
+    assert_equal [:on_connection_close], d.server.handler.names
+    assert_equal [], d.client.handler.names
+    d.server.connection.close; d.run
+    assert_equal [:on_connection_close, :on_transport_close], d.client.handler.names
+    assert_equal [:on_connection_close, :on_transport_close], d.server.handler.names
+  end
+
+  def test_transport_error
+    d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
+    d.client.connection.open; d.run
+    d.clear
+    d.client.close "stop that"; d.run
+    assert_equal [:on_transport_close], d.client.handler.names
+    assert_equal [:on_transport_error, :on_transport_close], d.server.handler.names
+    assert_equal Condition.new("proton:io", "stop that (connection aborted)"), d.client.transport.condition
+    assert_equal Condition.new("amqp:connection:framing-error", "connection aborted"), d.server.transport.condition
+  end
+
+  # Close on half-open
+  def test_connection_error
+    d = DriverPair.new(NoAutoOpenClose.new, NoAutoOpenClose.new)
+    d.client.connection.open; d.run
+    d.server.connection.close "bad dog"; d.run
+    d.client.connection.close; d.run
+    assert_equal [:on_connection_open, :on_connection_error, :on_connection_close, :on_transport_close], d.client.handler.names
+    assert_equal "bad dog", d.client.handler.calls[1][1].condition.description
+    assert_equal [:on_connection_open, :on_connection_error, :on_connection_close, :on_transport_close], d.server.handler.names
+  end
+
+  def test_session_error
+    d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
+    d.client.connection.open
+    s = d.client.connection.session; s.open; d.run
+    assert_equal [:on_connection_open, :on_session_open], d.client.handler.names
+    assert_equal [:on_connection_open, :on_session_open], d.server.handler.names
+    d.clear
+    s.close "bad dog"; d.run
+    assert_equal [:on_session_error, :on_session_close], d.client.handler.names
+    assert_equal [:on_session_error, :on_session_close], d.server.handler.names
+    assert_equal "bad dog", d.server.handler.calls[0][1].condition.description
+  end
+
+  def test_sender_receiver_error
+    d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
+    d.client.connection.open
+    s = d.client.connection.open_sender; d.run
+    assert_equal [:on_connection_open, :on_session_open, :on_sender_open, :on_sendable], d.client.handler.names
+    assert_equal [:on_connection_open, :on_session_open, :on_receiver_open], d.server.handler.names
+    d.clear
+    s.close "bad dog"; d.run
+    assert_equal [:on_sender_error, :on_sender_close], d.client.handler.names
+    assert_equal [:on_receiver_error, :on_receiver_close], d.server.handler.names
+    assert_equal "bad dog", d.server.handler.calls[0][1].condition.description
+  end
+
+  def test_options_off
+    linkopts = {:credit_window=>0, :auto_settle=>false, :auto_accept=>false}
+    d = DriverPair.new(NoAutoOpenClose.new, NoAutoOpenClose.new)
+    d.client.connection.open; d.run
+    assert_equal [[], [:on_connection_open]], d.names
+    d.server.connection.open; d.run
+    assert_equal [[:on_connection_open], [:on_connection_open]], d.names
+    d.clear
+    s = d.client.connection.open_sender(linkopts); d.run
+    assert_equal [[], [:on_session_open, :on_receiver_open]], d.names
+    d.server.handler.session.open      # Return session open
+    d.server.handler.link.open(linkopts) # Return link open
+    d.run
+    assert_equal [[:on_session_open, :on_sender_open], [:on_session_open, :on_receiver_open]], d.names
+    d.clear
+    d.server.handler.link.flow(1); d.run
+    assert_equal [[:on_sendable], []], d.names
+    assert_equal 1, s.credit
+    d.clear
+    s.send Message.new("foo"); d.run
+    assert_equal [[], [:on_message]], d.names
+  end
+
+  def test_message
+    handler_class = Class.new(MessagingHandler) do
+      def on_message(delivery, message) @message = message; end
+      def on_tracker_accept(event) @accepted = true; end
+      attr_accessor :message, :accepted
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open;
+    s = d.client.connection.open_sender; d.run
+    assert_equal 10, s.credit   # Default prefetch
+    s.send(Message.new("foo")); d.run
+    assert_equal "foo", d.server.handler.message.body
+    assert d.client.handler.accepted
+  end
+
+  # Verify on_unhandled is called
+  def test_unhandled
+    handler_class = Class.new(MessagingHandler) do
+      def initialize() super; @unhandled = []; end
+      def on_unhandled(method, *args) @unhandled << method; end
+      attr_accessor :unhandled
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open; d.run
+    assert_equal [:on_connection_open], d.client.handler.unhandled
+    assert_equal [:on_connection_open], d.server.handler.unhandled
+  end
+
+  # Verify on_error is called
+  def test_on_error
+    handler_class = Class.new(MessagingHandler) do
+      def initialize() super; @error = []; @unhandled = []; end
+      def on_error(condition) @error << condition; end
+      def on_unhandled(method, *args) @unhandled << method; end
+      attr_accessor :error, :unhandled
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open
+    r = d.client.connection.open_receiver; d.run
+    assert_equal [:on_connection_open, :on_session_open, :on_receiver_open], d.client.handler.unhandled
+    assert_equal [:on_connection_open, :on_session_open, :on_sender_open, :on_sendable], d.server.handler.unhandled
+    r.close Condition.new("goof", "oops"); d.run
+
+    assert_equal [Condition.new("goof", "oops")], d.client.handler.error
+    assert_equal [:on_connection_open, :on_session_open, :on_sender_open, :on_sendable, :on_sender_close], d.server.handler.unhandled
+    assert_equal [Condition.new("goof", "oops")], d.server.handler.error
+
+  end
+
+  # Verify on_unhandled is called for errors if there is no on_error
+  def test_unhandled_error
+    handler_class = Class.new(MessagingHandler) do
+      def on_unhandled(method, *args)
+        @error = args[0].condition if method == :on_connection_error;
+      end
+      attr_accessor :error
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open; d.run
+    d.client.connection.close "oops"; d.run
+    assert_equal [Condition.new("error", "oops")]*2, d.collect { |x| x.handler.error }
+  end
+end

data/tests/test_old_adapter.rb

@@ -0,0 +1,228 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+require 'minitest/autorun'
+require 'qpid_proton'
+require 'test_tools'
+include Qpid::Proton
+
+OldMessagingHandler = Qpid::Proton::Handler::MessagingHandler #Use the old handler.
+
+# Records every call
+class AllHandler < OldMessagingHandler
+  def initialize(*args)
+    super(*args)
+    @calls = []
+  end
+
+  attr_accessor :calls
+
+  def names; @calls.map { |c| c[0] }; end
+  def events; @calls.map { |c| c[1] }; end
+
+  def method_missing(name, *args) (/^on_/ =~ name) ? (@calls << [name] + args) : super; end
+  def respond_to_missing?(name, private=false); (/^on_/ =~ name); end
+  def respond_to?(name, all=false) super || respond_to_missing?(name); end # For ruby < 1.9.2
+end
+
+# Tests with Mock handler that handles all methods, expect both old and new calls
+class TestOldHandler < MiniTest::Test
+  def setup
+    @h = [AllHandler.new, AllHandler.new]
+    @ch, @sh = *@h
+    @d = DriverPair.new(*@h)
+  end
+
+  def clear; @d.each { |d| h = d.handler; h.calls.clear }; end
+
+  def test_handler_defaults
+    want = { :prefetch => 10, :auto_settle => true, :auto_accept => true, :auto_open => true, :auto_close => true, :peer_close_is_error => false }
+    assert_equal want, @ch.options
+    assert_equal want, @sh.options
+  end
+
+  def test_auto_open_close
+    @d.client.connection.open; @d.client.connection.open_sender; @d.run
+    assert_equal [:on_connection_opened, :on_session_opened, :on_link_opened, :on_sendable], @ch.names
+    assert_equal [:on_connection_opening, :on_session_opening, :on_link_opening, :on_connection_opened, :on_session_opened, :on_link_opened], @sh.names
+    clear
+    @d.client.connection.close; @d.run
+    assert_equal [:on_connection_closed, :on_transport_closed], @ch.names
+    assert_equal [:on_connection_closing, :on_connection_closed, :on_transport_closed], @sh.names
+  end
+
+  def test_no_auto_open_close
+    [:auto_close, :auto_open].each { |k| @ch.options[k] = @sh.options[k] = false }
+    @d.client.connection.open; @d.run
+    assert_equal [:on_connection_opening], @sh.names
+    assert_equal [], @ch.names
+    @d.server.connection.open; @d.run
+    assert_equal [:on_connection_opened], @ch.names
+    assert_equal [:on_connection_opening, :on_connection_opened], @sh.names
+    clear
+    @d.client.connection.session.open; @d.run
+    assert_equal [:on_session_opening], @sh.names
+    assert_equal [], @ch.names
+    clear
+    @d.client.connection.close;
+    3.times { @d.process }
+    assert_equal [:on_connection_closing], @sh.names
+    assert_equal [], @ch.names
+    @d.server.connection.close; @d.run
+    assert_equal [:on_connection_closed, :on_transport_closed], @ch.names
+    assert_equal [:on_connection_closing, :on_connection_closed, :on_transport_closed], @sh.names
+  end
+
+  def test_transport_error
+    @d.client.connection.open; @d.run
+    clear
+    @d.client.close "stop that"; @d.run
+    assert_equal [:on_transport_closed], @ch.names
+    assert_equal [:on_transport_error, :on_transport_closed], @sh.names
+    assert_equal Condition.new("proton:io", "stop that (connection aborted)"), @d.client.transport.condition
+    assert_equal Condition.new("amqp:connection:framing-error", "connection aborted"), @d.server.transport.condition
+  end
+
+  def test_connection_error
+    @ch.options[:auto_open] = @sh.options[:auto_open] = false
+    @d.client.connection.open; @d.run
+    @d.server.connection.close "bad dog"; @d.run
+    assert_equal [:on_connection_opened, :on_connection_error, :on_connection_closed, :on_transport_closed], @ch.names
+    assert_equal "bad dog", @ch.calls[2][1].condition.description
+    assert_equal [:on_connection_opening, :on_connection_closed, :on_transport_closed], @sh.names
+  end
+
+  def test_session_error
+    @d.client.connection.open
+    s = @d.client.connection.session; s.open; @d.run
+    s.close "bad dog"; @d.run
+    assert_equal [:on_connection_opened, :on_session_opened, :on_session_closed], @ch.names
+    assert_equal [:on_connection_opening, :on_session_opening, :on_connection_opened, :on_session_opened, :on_session_error, :on_session_closed], @sh.names
+    assert_equal "bad dog", @sh.calls[-3][1].condition.description
+  end
+
+  def test_link_error
+    @d.client.connection.open
+    s = @d.client.connection.open_sender; @d.run
+    s.close "bad dog"; @d.run
+    assert_equal [:on_connection_opened, :on_session_opened, :on_link_opened, :on_sendable, :on_link_closed], @ch.names
+    assert_equal [:on_connection_opening, :on_session_opening, :on_link_opening,
+                  :on_connection_opened, :on_session_opened, :on_link_opened,
+                  :on_link_error, :on_link_closed], @sh.names
+    assert_equal "bad dog", @sh.calls[-3][1].condition.description
+  end
+
+  def test_options_off
+    off = {:prefetch => 0, :auto_settle => false, :auto_accept => false, :auto_open => false, :auto_close => false}
+    @ch.options.replace(off)
+    @sh.options.replace(off)
+    @d.client.connection.open; @d.run
+    assert_equal [[], [:on_connection_opening]], [@ch.names, @sh.names]
+    @d.server.connection.open; @d.run
+    assert_equal [[:on_connection_opened], [:on_connection_opening, :on_connection_opened]], [@ch.names, @sh.names]
+    clear
+    s = @d.client.connection.open_sender; @d.run
+    assert_equal [[], [:on_session_opening, :on_link_opening]], [@ch.names, @sh.names]
+    @sh.events[1].session.open
+    r = @sh.events[1].link
+    r.open; @d.run
+    assert_equal [[:on_session_opened, :on_link_opened], [:on_session_opening, :on_link_opening, :on_session_opened, :on_link_opened]], [@ch.names, @sh.names]
+    clear
+    r.flow(1); @d.run
+    assert_equal [[:on_sendable], []], [@ch.names, @sh.names]
+    assert_equal 1, s.credit
+    clear
+    s.send Message.new("foo"); @d.run
+    assert_equal [[], [:on_message]], [@ch.names, @sh.names]
+  end
+
+  def test_peer_close_is_error
+    @ch.options[:peer_close_is_error] = true
+    @d.client.connection.open; @d.run
+    @d.server.connection.close; @d.run
+    assert_equal [:on_connection_opened, :on_connection_error, :on_connection_closed, :on_transport_closed], @ch.names
+    assert_equal [:on_connection_opening, :on_connection_opened, :on_connection_closed, :on_transport_closed], @sh.names
+  end
+end
+
+# Test with real handlers that implement a few methods
+class TestOldUnhandled < MiniTest::Test
+
+  def test_message
+    handler_class = Class.new(OldMessagingHandler) do
+      def on_message(event) @message = event.message; end
+      def on_accepted(event) @accepted = true; end
+      attr_accessor :message, :accepted, :sender
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open;
+    s = d.client.connection.open_sender; d.run
+    assert_equal 10, s.credit   # Default prefetch
+    s.send(Message.new("foo")); d.run
+    assert_equal "foo", d.server.handler.message.body
+    assert d.client.handler.accepted
+  end
+
+  # Verify on_unhandled is called
+  def test_unhandled
+    handler_class = Class.new(OldMessagingHandler) do
+      def initialize() super; @unhandled = []; end
+      def on_unhandled(event) @unhandled << event.method; end
+      attr_accessor :unhandled
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open; d.run
+    assert_equal [:on_connection_opened], d.client.handler.unhandled
+    assert_equal [:on_connection_opening, :on_connection_opened], d.server.handler.unhandled
+  end
+
+  # Verify on_error is called
+  def test_on_error
+    handler_class = Class.new(OldMessagingHandler) do
+      def initialize() super; @error = []; @unhandled = []; end
+      def on_error(event) @error << event.method; end
+      def on_unhandled(event) @unhandled << event.method; end
+      attr_accessor :error, :unhandled
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open
+    r = d.client.connection.open_receiver; d.run
+    r.close "oops"; d.run
+    assert_equal [:on_connection_opened, :on_session_opened, :on_link_opened,
+                  :on_link_closed], d.client.handler.unhandled
+    assert_equal [:on_connection_opening, :on_session_opening, :on_link_opening,
+                  :on_connection_opened, :on_session_opened, :on_link_opened, :on_sendable,
+                  :on_link_closed], d.server.handler.unhandled
+    assert_equal [:on_link_error], d.server.handler.error
+
+  end
+
+  # Verify on_unhandled is called even for errors if there is no on_error
+  def test_unhandled_error
+    handler_class = Class.new(OldMessagingHandler) do
+      def initialize() super; @unhandled = []; end
+      def on_unhandled(event) @unhandled << event.method; end
+      attr_accessor :unhandled
+    end
+    d = DriverPair.new(handler_class.new, handler_class.new)
+    d.client.connection.open; d.run
+    d.client.connection.close "oops"; d.run
+    assert_equal [:on_connection_opened, :on_connection_closed, :on_transport_closed], d.client.handler.unhandled
+    assert_equal [:on_connection_opening, :on_connection_opened, :on_connection_error, :on_connection_closed, :on_transport_closed], d.server.handler.unhandled
+  end
+end