KEP-1151 Add new attributes to the status message

* swarm id added to status response
* size request includes max_size if one is set

crud/crud.cpp

@@ -555,6 +555,7 @@ crud::handle_size(const bzn::caller_id_t& /*caller_id*/, const database_msg& req
     if (const auto max_size = this->max_database_size(perms); max_size)
     {
         response.mutable_size()->set_remaining_bytes((size < max_size) ? (max_size - size) : (0));
+        response.mutable_size()->set_max_size(max_size);
     }
 
     this->send_response(request, bzn::storage_result::ok, std::move(response), session);

crud/test/crud_test.cpp

@@ -1544,6 +1544,7 @@ TEST(crud, test_that_size_sends_proper_response)
     msg.mutable_header()->set_db_uuid("uuid");
     msg.mutable_header()->set_nonce(uint64_t(123));
     msg.mutable_create_db();
+    msg.mutable_create_db()->set_max_size(1234);
 
     crud->handle_request("caller_id", msg, nullptr);
 
@@ -1568,6 +1569,7 @@ TEST(crud, test_that_size_sends_proper_response)
         {
             ASSERT_EQ(resp.size().bytes(), uint64_t(8));
             ASSERT_EQ(resp.size().keys(), uint32_t(1));
+            ASSERT_EQ(resp.size().max_size(), uint64_t(1234));
         });
 
     crud->handle_request("caller_id", msg, session);
@@ -3142,4 +3144,4 @@ TEST(crud, test_that_two_cruds_evict_the_same_key_value_pairs)
 
     remove_test_database(crud_0, session_0, mock_node_0, CALLER_UUID, DB_UUID);
     remove_test_database(crud_1, session_1, mock_node_1, CALLER_UUID, DB_UUID);
-}
+}

include/bluzelle.hpp

@@ -40,6 +40,8 @@ namespace bzn
 
     using value_t = std::string;
 
+    using swarm_id_t = std::string;
+
 } // bzn
 
 

mocks/mock_options_base.hpp

@@ -44,6 +44,8 @@ class mock_options_base : public options_base {
       bool());
   MOCK_CONST_METHOD0(get_uuid,
       bzn::uuid_t());
+  MOCK_CONST_METHOD0(get_swarm_id,
+        bzn::swarm_id_t());
   MOCK_CONST_METHOD0(get_ws_idle_timeout,
       std::chrono::milliseconds());
   MOCK_CONST_METHOD0(get_audit_mem_size,

options/options.cpp

@@ -128,6 +128,12 @@ options::get_uuid() const
     return boost::beast::detail::base64_encode(pubkey_raw);
 }
 
+bzn::swarm_id_t
+options::get_swarm_id() const
+{
+    return this->raw_opts.get<std::string>(SWARM_ID);
+}
+
 bool
 options::get_debug_logging() const
 {

options/options.hpp

@@ -47,6 +47,8 @@ namespace bzn
 
         bzn::uuid_t get_uuid() const override;
 
+        bzn::swarm_id_t get_swarm_id() const override;
+
         std::chrono::milliseconds get_ws_idle_timeout() const override;
 
         size_t get_audit_mem_size() const override;

options/options_base.hpp

@@ -107,6 +107,12 @@ namespace bzn
          */
         virtual bzn::uuid_t get_uuid() const = 0;
 
+        /**
+         * Get the swarm id this peer belongs to
+         * @return swarm_id
+         */
+        virtual bzn::swarm_id_t get_swarm_id() const = 0;
+
         /**
          * Get the websocket activity timeout
          * @return seconds

options/simple_options.cpp

@@ -84,6 +84,9 @@ simple_options::build_options()
                 (NODE_UUID.c_str(),
                         po::value<std::string>(),
                         "uuid of this node")
+                (SWARM_ID.c_str(),
+                        po::value<std::string>(),
+                        "swarm id of this node")
                 (STATE_DIR.c_str(),
                         po::value<std::string>()->default_value("./.state/"),
                         "location for state files")

options/simple_options.hpp

@@ -44,6 +44,7 @@ namespace bzn::option_names
     const std::string NODE_PUBKEY_FILE = "public_key_file";
     const std::string NODE_PRIVATEKEY_FILE = "private_key_file";
     const std::string STATE_DIR = "state_dir";
+    const std::string SWARM_ID = "swarm_id";
     const std::string WS_IDLE_TIMEOUT = "ws_idle_timeout";
     const std::string PEER_VALIDATION_ENABLED = "peer_validation_enabled";
     const std::string SIGNED_KEY = "signed_key";

options/test/options_test.cpp

@@ -37,6 +37,7 @@ namespace
         "  \"bootstrap_file\" : \"peers.json\",\n"
         "  \"bootstrap_url\"  : \"example.org/peers.json\",\n"
         "  \"uuid\" : \"c05c0dff-3c27-4532-96de-36f53d8a278e\",\n"
+        "  \"swarm_id\" : \"utest\",\n"
         "  \"debug_logging\" : true,"
         "  \"log_to_stdout\" : true,"
         "  \"state_dir\" : \"./daemon_state/\","
@@ -140,6 +141,7 @@ TEST_F(options_file_test, test_that_loading_of_default_config_file)
     EXPECT_EQ(DEFAULT_LISTENER, options.get_listener());
     ASSERT_EQ(true, options.get_debug_logging());
     ASSERT_EQ(true, options.get_log_to_stdout());
+    EXPECT_EQ("utest", options.get_swarm_id());
     EXPECT_EQ("./daemon_state/", options.get_state_dir());
     EXPECT_EQ("peers.json", options.get_bootstrap_peers_file());
     EXPECT_EQ("example.org/peers.json", options.get_bootstrap_peers_url());
@@ -165,6 +167,7 @@ TEST_F(options_file_test, test_that_loading_of_default_config_file)
         EXPECT_EQ(size_t(65536), options.get_logfile_rotation_size());
         EXPECT_EQ("logs/", options.get_logfile_dir());
         EXPECT_TRUE(options.get_mem_storage());
+        EXPECT_EQ("", options.get_swarm_id());
     }
 }
 
@@ -341,5 +344,4 @@ TEST_F(options_file_test, test_set_option_at_runtime)
     EXPECT_TRUE(options.get_simple_options().get<bool>(bzn::option_names::DEBUG_LOGGING));
     options.get_mutable_simple_options().set(bzn::option_names::DEBUG_LOGGING, "false");
     EXPECT_FALSE(options.get_simple_options().get<bool>(bzn::option_names::DEBUG_LOGGING));
-
 }

proto/database.proto

@@ -188,6 +188,7 @@ message database_size_response
     uint64 bytes = 1;
     uint32 keys = 2;
     uint64 remaining_bytes = 3;
+    uint64 max_size = 4;
 }
 
 message database_request {}

proto/status.proto

@@ -20,7 +20,8 @@ message status_response
 {
     string swarm_version = 1;
     string swarm_git_commit = 2;
-    string uptime = 3;
-    string module_status_json = 4;
-    bool pbft_enabled = 5;
+    string swarm_id = 3;
+    string uptime = 4;
+    string module_status_json = 5;
+    bool pbft_enabled = 6;
 }

status/status.cpp

@@ -43,9 +43,10 @@ namespace
 }
 
 
-status::status(std::shared_ptr<bzn::node_base> node, bzn::status::status_provider_list_t&& status_providers)
+status::status(std::shared_ptr<bzn::node_base> node, bzn::status::status_provider_list_t&& status_providers, const std::string& swarm_id)
     : node(std::move(node))
     , status_providers(std::move(status_providers))
+    , swarm_id(swarm_id)
     , start_time(std::chrono::steady_clock::now())
 {
 }
@@ -95,6 +96,7 @@ status::handle_status_request_message(const bzn_envelope& /*msg*/, std::shared_p
 
     srm.set_swarm_version(SWARM_VERSION);
     srm.set_swarm_git_commit(SWARM_GIT_COMMIT);
+    srm.set_swarm_id(this->swarm_id);
     srm.set_uptime(get_uptime(this->start_time));
     srm.set_pbft_enabled(true);
 

status/status.hpp

@@ -29,7 +29,7 @@ namespace bzn
     public:
         using status_provider_list_t = std::vector<std::weak_ptr<bzn::status_provider_base>>;
 
-        status(std::shared_ptr<bzn::node_base> node, status_provider_list_t&& status_providers);
+        status(std::shared_ptr<bzn::node_base> node, status_provider_list_t&& status_providers, const std::string& swarm_id);
 
         void start();
 
@@ -41,6 +41,7 @@ namespace bzn
         std::shared_ptr<bzn::node_base> node;
 
         status_provider_list_t status_providers;
+        const std::string swarm_id;
         std::once_flag start_once;
 
         const std::chrono::steady_clock::time_point start_time;

status/test/status_test.cpp

@@ -29,7 +29,7 @@ TEST(status_test, test_that_status_registers_and_responses_to_requests)
 
     // success
     {
-        auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{});
+        auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{}, "1234");
 
         EXPECT_CALL(*mock_node, register_for_message(bzn_envelope::kStatusRequest, _)).WillOnce(Return(true));
 
@@ -38,7 +38,7 @@ TEST(status_test, test_that_status_registers_and_responses_to_requests)
 
     // failure
     {
-        auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{});
+        auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{}, "1234");
 
         EXPECT_CALL(*mock_node, register_for_message(bzn_envelope::kStatusRequest, _)).WillOnce(Return(false));
 
@@ -49,12 +49,14 @@ TEST(status_test, test_that_status_registers_and_responses_to_requests)
 
 TEST(status_test, test_that_status_request_queries_status_providers)
 {
+    const std::string SWARM_ID{"utest"};
+
     auto mock_node = std::make_shared<Mocknode_base>();
     auto mock_session = std::make_shared<Mocksession_base>();
 
     auto mock_status_provider = std::make_shared<Mockstatus_provider_base>();
 
-    auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{mock_status_provider, mock_status_provider});
+    auto status = std::make_shared<bzn::status>(mock_node, bzn::status::status_provider_list_t{mock_status_provider, mock_status_provider}, SWARM_ID);
 
     bzn::protobuf_handler pbh;
     EXPECT_CALL(*mock_node, register_for_message(bzn_envelope::kStatusRequest, _)).WillOnce(Invoke(
@@ -88,6 +90,7 @@ TEST(status_test, test_that_status_request_queries_status_providers)
             ASSERT_TRUE(sr.ParseFromString(env->status_response()));
             ASSERT_TRUE(sr.pbft_enabled());
             ASSERT_EQ(sr.swarm_version(), SWARM_VERSION);
+            ASSERT_EQ(sr.swarm_id(), SWARM_ID);
             ASSERT_EQ(sr.swarm_git_commit(), SWARM_GIT_COMMIT);
             ASSERT_EQ(sr.uptime(), "0 days, 0 hours, 0 minutes");
 

swarm/main.cpp

@@ -167,7 +167,8 @@ print_banner(const bzn::options& options, double eth_balance)
     std::stringstream ss;
 
     ss << '\n';
-    ss << "  Running node with ID: " << options.get_uuid() << "\n"
+    ss << "              Swarm ID: " << options.get_swarm_id() << "\n"
+       << "  Running node with ID: " << options.get_uuid() << "\n"
        << "   Ethereum Address ID: " << options.get_ethererum_address()  << "\n"
        << "      Local IP Address: " << options.get_listener().address().to_string() << "\n"
        << "               On port: " << options.get_listener().port() << "\n"
@@ -285,7 +286,7 @@ main(int argc, const char* argv[])
 
         pbft->set_audit_enabled(options->get_simple_options().get<bool>(bzn::option_names::AUDIT_ENABLED));
 
-        auto status = std::make_shared<bzn::status>(node, bzn::status::status_provider_list_t{pbft});
+        auto status = std::make_shared<bzn::status>(node, bzn::status::status_provider_list_t{pbft}, options->get_swarm_id());
 
         node->start(pbft);
         chaos->start();