Fix error messages for user_exception. Change locator adapter not found exception.

Author: zmij

idl/wire/core/locator.wire

@@ -8,15 +8,21 @@
 #ifndef WIRE_CORE_LOCATOR_WIRE_
 #define WIRE_CORE_LOCATOR_WIRE_
 
-#include <wire/core/adapter_admin.wire>
 #include <wire/core/identity.wire>
 #include <wire/core/object.wire>
 
 namespace wire {
 namespace core {
 
 interface locator_registry;
-exception object_not_found{
+
+exception locator_error {};
+
+exception object_not_found : locator_error {
+    identity id;
+};
+
+exception adapter_not_found : locator_error {
     identity id;
 };
 
@@ -40,7 +46,7 @@ interface locator {
      */
     object*
     find_adapter(identity id) const
-        throw(no_adapter);
+        throw(adapter_not_found);
 
     /**
      * Get the locator registry object
@@ -114,7 +120,7 @@ interface locator_registry {
      */
     void
     remove_adapter(object* adapter)
-        throw(no_adapter);
+        throw(adapter_not_found);
 };
 
 }  /* namespace core */

include/wire/core/connection.hpp

@@ -116,7 +116,7 @@ class connection {
 
         using encoding::incoming;
         if (any(opts.flags & invocation_flags::one_way)) {
-            throw errors::runtime_error{ "Cannot send a non-void invocation one way" };
+            throw errors::invalid_one_way_invocation{ "Cannot send a non-void invocation one way" };
         }
         encoding::outgoing out{ get_connector() };
         encoding::write(::std::back_inserter(out), args ...);

include/wire/errors/exceptions.hpp

@@ -72,6 +72,7 @@ class connection_closed : public runtime_error {
 class connection_refused : public connection_closed {
 public:
     connection_refused(std::string const& msg) : connection_closed{msg} {}
+    connection_refused(char const* msg) : connection_closed{msg} {}
     template < typename ... T >
     connection_refused(T const& ... args) : connection_closed(args ...) {}
 };
@@ -82,6 +83,7 @@ class connection_refused : public connection_closed {
 class connection_failed : public connection_closed {
 public:
     connection_failed(std::string const& message) : connection_closed(message) {}
+    connection_failed(char const* msg) : connection_closed{msg} {}
     template < typename ... T >
     connection_failed(T const& ... args) : connection_closed(args ...) {}
 };
@@ -90,6 +92,7 @@ class connection_failed : public connection_closed {
 class request_timed_out : public runtime_error {
 public:
     request_timed_out(std::string const& msg) : runtime_error{msg} {}
+    request_timed_out(char const* msg) : runtime_error{msg} {}
     template < typename ... T >
     request_timed_out(T const& ... args) : runtime_error(args ...) {}
 };

include/wire/errors/user_exception.hpp

@@ -118,6 +118,8 @@ struct exception_reader {
     {
         using errors::user_exception_factory;
         auto tmp = user_exception_factory::instance().read< exception_value >(begin, end);
+        if (tmp)
+            tmp->post_unmarshal();
         ::std::swap(tmp, v);
     }
 };

src/wire/core/connection.cpp

@@ -91,7 +91,7 @@ create_listen_connection_impl(adapter_ptr adptr, functional::void_callback on_cl
         adapter_ptr a = adptr_weak.lock();
         // TODO Throw an error if adapter gone away
         if (!a) {
-            throw errors::runtime_error{ "Adapter gone away" };
+            throw errors::adapter_destroyed{ "Adapter gone away" };
         }
         return ::std::make_shared< Session >( server_side{}, a, on_close );
     }, on_close);

src/wire/core/connector.cpp

@@ -617,7 +617,7 @@ struct connector::impl {
     {
         connector_ptr conn = owner_.lock();
         if (!conn) {
-            throw errors::runtime_error("Connector already destroyed");
+            throw errors::connector_destroyed{"Connector already destroyed"};
         }
         if (find_adapter(id))
             throw errors::runtime_error("Adapter ", id, " is already configured");
@@ -631,7 +631,7 @@ struct connector::impl {
     {
         connector_ptr conn = owner_.lock();
         if (!conn) {
-            throw errors::runtime_error("Connector already destroyed");
+            throw errors::connector_destroyed{"Connector already destroyed"};
         }
         detail::adapter_options opts { {}, 0, false, -1, 0, false, options_.client_ssl};
             bidir_adapter_ = adapter::create_adapter(

src/wire/core/connector_admin_impl.cpp

@@ -23,7 +23,7 @@ connector_admin_impl::get_adapter_ids(current const&) const
     auto cnctr = get_connector();
     if (cnctr)
         return cnctr->adapter_ids();
-    throw errors::runtime_error{ "Connector is shut down" };
+    throw errors::connector_destroyed{ "Connector is shut down" };
 }
 void
 connector_admin_impl::get_adapter_state(identity const& adapter_id,

src/wire/core/reference.cpp

@@ -109,7 +109,7 @@ reference::get_connector() const
 {
     auto cnctr = connector_.lock();
     if (!cnctr)
-        throw errors::runtime_error{ "Connector already destroyed" };
+        throw errors::connector_destroyed{ "Connector already destroyed" };
     return cnctr;
 }
 

src/wire/locator/locator_impl.cpp

@@ -196,7 +196,7 @@ struct locator::impl {
         if (adapters_.find(f, id)) {
             return f->second;
         }
-        throw core::no_adapter{id};
+        throw core::adapter_not_found{id};
     }
 
     void
@@ -268,7 +268,7 @@ struct locator::impl {
         auto id = adapter->wire_identity();
         proxy_map::accessor f;
         if (!adapters_.find(f, id)) {
-            throw core::no_adapter{id};
+            throw core::adapter_not_found{id};
         } else {
             #if DEBUG_OUTPUT >= 1
             ::std::cerr <<::getpid() << " Locator remove adapter " << *adapter << "\n";

test/encoding/exception_io_test.cpp

@@ -23,6 +23,8 @@ ::std::string const BASE =  "::test::base_type";
 }  /* namespace  */
 
 class base : public errors::user_exception {
+public:
+    using ptr = ::std::shared_ptr<base>;
 public:
     base() : user_exception{} {}
     explicit
@@ -68,9 +70,22 @@ class base : public errors::user_exception {
     ::std::exception_ptr
     make_exception_ptr() override
     { return ::std::make_exception_ptr(*this); }
+protected:
+    void
+    stream_message(::std::ostream& os) const override
+    {
+        os << "base exception";
+    }
+private:
+    using factory_init_type = errors::user_exception_factory_init< base >;
+    static factory_init_type _factory_init_;
 };
 
+base::factory_init_type base::_factory_init_;
+
 class derived : public base {
+public:
+    using ptr = ::std::shared_ptr<derived>;
 public:
     derived() : base{}, some_int{} {};
 
@@ -119,8 +134,50 @@ class derived : public base {
     { return ::std::make_exception_ptr(*this); }
 public:
     ::std::int32_t      some_int;
+
+protected:
+    void
+    stream_message(::std::ostream& os) const override
+    {
+        os << "derived exception " << some_int;
+    }
+
+private:
+    using factory_init_type = errors::user_exception_factory_init<derived>;
+    static factory_init_type _factory_init_;
 };
 
+derived::factory_init_type derived::_factory_init_;
+
+}
+
+namespace detail {
+
+template <>
+struct is_user_exception<test::base> : ::std::true_type {};
+template <>
+struct is_user_exception<test::derived> : ::std::true_type {};
+
+} /* namespace detail */
+
+
+namespace test {
+
+static_assert( detail::is_user_exception<base>::value,
+        "Traits for base object are correct" );
+static_assert( detail::is_user_exception<derived>::value,
+        "Traits for derived object are correct" );
+
+static_assert( detail::wire_type< base::ptr >::value == detail::wire_types::EXCEPTION,
+        "Correct wire type for base object");
+static_assert( detail::wire_type< derived::ptr >::value == detail::wire_types::EXCEPTION,
+        "Correct wire type for derived object");
+
+static_assert( ::std::is_base_of< detail::exception_reader<base>, detail::reader<base::ptr> >::value,
+        "Correct reader for base object");
+static_assert( ::std::is_base_of< detail::exception_reader<derived>, detail::reader<derived::ptr> >::value,
+        "Correct reader for base object");
+
 TEST(IO, UserException)
 {
     outgoing out{ core::connector_ptr{} };
@@ -149,12 +206,60 @@ TEST(IO, UserException)
         ::std::cerr << "Encaps size " << encaps.size() << "\n";
         ::std::cerr << "Data left " << (encaps.end() - f) << "\n";
         EXPECT_NO_THROW(e.__wire_read(f, l, true));
+        EXPECT_NO_THROW(e.post_unmarshal());
         ::std::cerr << "Data left " << (encaps.end() - f) << "\n";
+        EXPECT_EQ(::std::string{"base exception"}, e.what());
         derived d;
         l = encaps.end();
         EXPECT_NO_THROW(d.__wire_read(f, l, true));
+        EXPECT_NO_THROW(d.post_unmarshal());
         ::std::cerr << "Data left " << (encaps.end() - f) << "\n";
         EXPECT_EQ(100500, d.some_int);
+        EXPECT_EQ(::std::string{"derived exception 100500"}, d.what());
+    }
+}
+
+TEST(IO, UserExceptionFactory)
+{
+    outgoing out{ core::connector_ptr{} };
+    {
+        auto encaps = out.current_encapsulation();
+        auto o = ::std::back_inserter(out);
+        base e("ooops");
+        e.__wire_write(o);
+        ::std::cerr << "Encaps size " << encaps.size() << "\n";
+        derived d{100500};
+        d.__wire_write(o);
+        ::std::cerr << "Encaps size " << encaps.size() << "\n";
+        EXPECT_FALSE(encaps.empty());
+    }
+    incoming in{ message{}, ::std::move(out) };
+    {
+        auto encaps = in.current_encapsulation();
+        EXPECT_FALSE(encaps.empty());
+
+        auto f = encaps.begin();
+        auto l = encaps.end();
+        ::std::cerr << "Encaps size " << encaps.size() << "\n";
+        ::std::cerr << "Data left " << (encaps.end() - f) << "\n";
+
+        errors::user_exception_ptr e, d;
+        read(f, l, e);
+        read(f, l, d);
+        encaps.read_indirection_table(f);
+
+        ASSERT_TRUE(e.get());
+        ASSERT_TRUE(d.get());
+
+        auto bs = ::std::dynamic_pointer_cast< base >(e);
+        EXPECT_TRUE(bs.get()) << "Correct type info";
+        auto dv = ::std::dynamic_pointer_cast< derived >(e);
+        EXPECT_FALSE(dv.get()) << "Correct type info";
+        dv = ::std::dynamic_pointer_cast< derived >(d);
+        EXPECT_TRUE(dv.get()) << "Correct type info";
+
+        EXPECT_EQ(::std::string{"base exception"}, e->what());
+        EXPECT_EQ(::std::string{"derived exception 100500"}, d->what());
     }
 }