gemmellr commented on a change in pull request #346:
URL: https://github.com/apache/qpid-proton/pull/346#discussion_r773945393
##########
File path: cpp/src/link_test.cpp
##########
@@ -23,9 +23,121 @@
#include <proton/sender_options.hpp>
#include <proton/receiver_options.hpp>
#include <proton/container.hpp>
+#include <proton/connection.hpp>
+#include <proton/connection_options.hpp>
+#include <proton/listen_handler.hpp>
+#include <proton/listener.hpp>
+#include <proton/messaging_handler.hpp>
+#include <proton/types.hpp>
+#include <proton/message.hpp>
+#include <proton/target_options.hpp>
+#include <proton/source_options.hpp>
+#include <proton/delivery.hpp>
#include <iostream>
+#include <map>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+namespace {
+std::mutex m;
+std::condition_variable cv;
+bool listener_ready = false;
+int listener_port;
+const std::string DYNAMIC_ADDRESS = "test_dynamic_address";
+} // namespace
+
+class test_recv : public proton::messaging_handler {
+ private:
+ class listener_ready_handler : public proton::listen_handler {
+ void on_open(proton::listener &l) override {
+ {
+ std::lock_guard<std::mutex> lk(m);
+ listener_port = l.port();
+ listener_ready = true;
+ }
+ cv.notify_one();
+ }
+ };
+
+ std::string url;
+ proton::listener listener;
+ listener_ready_handler listen_handler;
+
+ public:
+ test_recv(const std::string &s) : url(s) {}
+
+ void on_container_start(proton::container &c) override {
+ listener = c.listen(url, listen_handler);
+ }
+
+ void on_receiver_open(proton::receiver& r) override {
+ std::map<proton::symbol,proton::value>
m_sender({{proton::symbol("supported-dist-modes"), proton::symbol("move")}});
+ std::map<proton::symbol,proton::value> props =
r.target().dynamic_properties();
+
+ ASSERT(r.target().dynamic());
+ ASSERT(r.target().address().empty());
Review comment:
Is this checking for an empty string or for null (or either)? I would
expect the address not to be present at all, i.e null. The empty string is
another thing entirely.
##########
File path: cpp/src/link_test.cpp
##########
@@ -23,9 +23,121 @@
#include <proton/sender_options.hpp>
#include <proton/receiver_options.hpp>
#include <proton/container.hpp>
+#include <proton/connection.hpp>
+#include <proton/connection_options.hpp>
+#include <proton/listen_handler.hpp>
+#include <proton/listener.hpp>
+#include <proton/messaging_handler.hpp>
+#include <proton/types.hpp>
+#include <proton/message.hpp>
+#include <proton/target_options.hpp>
+#include <proton/source_options.hpp>
+#include <proton/delivery.hpp>
#include <iostream>
+#include <map>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+namespace {
+std::mutex m;
+std::condition_variable cv;
+bool listener_ready = false;
+int listener_port;
+const std::string DYNAMIC_ADDRESS = "test_dynamic_address";
+} // namespace
+
+class test_recv : public proton::messaging_handler {
+ private:
+ class listener_ready_handler : public proton::listen_handler {
+ void on_open(proton::listener &l) override {
+ {
+ std::lock_guard<std::mutex> lk(m);
+ listener_port = l.port();
+ listener_ready = true;
+ }
+ cv.notify_one();
+ }
+ };
+
+ std::string url;
+ proton::listener listener;
+ listener_ready_handler listen_handler;
+
+ public:
+ test_recv(const std::string &s) : url(s) {}
+
+ void on_container_start(proton::container &c) override {
+ listener = c.listen(url, listen_handler);
+ }
+
+ void on_receiver_open(proton::receiver& r) override {
+ std::map<proton::symbol,proton::value>
m_sender({{proton::symbol("supported-dist-modes"), proton::symbol("move")}});
+ std::map<proton::symbol,proton::value> props =
r.target().dynamic_properties();
+
+ ASSERT(r.target().dynamic());
+ ASSERT(r.target().address().empty());
+ ASSERT_EQUAL(m_sender, props);
+
+ proton::target_options opts;
+ std::map<proton::symbol, proton::value>
m({{proton::symbol("supported-dist-modes"), proton::symbol("copy")}});
+ opts.address(DYNAMIC_ADDRESS);
+ opts.dynamic_properties(m);
+ if (r.uninitialized()) {
+ r.open(proton::receiver_options().target(opts));
+ }
+ listener.stop();
+ }
+};
+
+class test_send : public proton::messaging_handler {
+ private:
+ std::string url;
+
+ public:
+ test_send(const std::string& s) : url(s) {}
+
+ void on_container_start(proton::container& c) override {
+ proton::target_options opts;
+ std::map<proton::symbol,proton::value>
m({{proton::symbol("supported-dist-modes"), proton::symbol("move")}});
+ opts.dynamic(true);
+ opts.dynamic_properties(m);
+ c.open_sender(url, proton::sender_options().target(opts));
Review comment:
This continues to use a sender from the clients perspective. If we only
test one of them then I think it should be initiating a receiver as thats what
people will mostly tend to do, whereas this is testing a dynamic sender which
is something that few will ever do.
##########
File path: cpp/src/link_test.cpp
##########
@@ -23,9 +23,121 @@
#include <proton/sender_options.hpp>
#include <proton/receiver_options.hpp>
#include <proton/container.hpp>
+#include <proton/connection.hpp>
+#include <proton/connection_options.hpp>
+#include <proton/listen_handler.hpp>
+#include <proton/listener.hpp>
+#include <proton/messaging_handler.hpp>
+#include <proton/types.hpp>
+#include <proton/message.hpp>
+#include <proton/target_options.hpp>
+#include <proton/source_options.hpp>
+#include <proton/delivery.hpp>
#include <iostream>
+#include <map>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+namespace {
+std::mutex m;
+std::condition_variable cv;
+bool listener_ready = false;
+int listener_port;
+const std::string DYNAMIC_ADDRESS = "test_dynamic_address";
+} // namespace
+
+class test_recv : public proton::messaging_handler {
+ private:
+ class listener_ready_handler : public proton::listen_handler {
+ void on_open(proton::listener &l) override {
+ {
+ std::lock_guard<std::mutex> lk(m);
+ listener_port = l.port();
+ listener_ready = true;
+ }
+ cv.notify_one();
+ }
+ };
+
+ std::string url;
+ proton::listener listener;
+ listener_ready_handler listen_handler;
+
+ public:
+ test_recv(const std::string &s) : url(s) {}
+
+ void on_container_start(proton::container &c) override {
+ listener = c.listen(url, listen_handler);
+ }
+
+ void on_receiver_open(proton::receiver& r) override {
+ std::map<proton::symbol,proton::value>
m_sender({{proton::symbol("supported-dist-modes"), proton::symbol("move")}});
+ std::map<proton::symbol,proton::value> props =
r.target().dynamic_properties();
+
+ ASSERT(r.target().dynamic());
+ ASSERT(r.target().address().empty());
+ ASSERT_EQUAL(m_sender, props);
+
+ proton::target_options opts;
+ std::map<proton::symbol, proton::value>
m({{proton::symbol("supported-dist-modes"), proton::symbol("copy")}});
+ opts.address(DYNAMIC_ADDRESS);
+ opts.dynamic_properties(m);
+ if (r.uninitialized()) {
Review comment:
Is this checking the link isnt open/closed already so it doesnt try to
open it again? If so I dont really understand the need for this in this test,
as the server peer should never initiate the link. If the check is needed I
would probably expect an else that failed the test somehow.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
