couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

data/ext/couchbase/cluster.hxx

@@ -19,124 +19,76 @@
 
 #include <utility>
 #include <thread>
+#include <fstream>
+
+#include <asio/ssl.hpp>
 
 #include <io/mcbp_session.hxx>
-#include <io/session_manager.hxx>
+#include <io/http_session_manager.hxx>
+#include <io/http_command.hxx>
+#include <io/dns_client.hxx>
+#include <origin.hxx>
 #include <bucket.hxx>
 #include <operations.hxx>
 #include <operations/document_query.hxx>
 
 namespace couchbase
 {
-struct origin {
-    std::string username;
-    std::string password;
-    std::string hostname;
-
-    [[nodiscard]] const std::string& get_username() const
-    {
-        return username;
-    }
-
-    [[nodiscard]] const std::string& get_password() const
-    {
-        return password;
-    }
-
-    [[nodiscard]] std::pair<std::string, std::string> get_address() const
-    {
-        return { hostname, "11210" };
-    }
-};
-
 class cluster
 {
   public:
     explicit cluster(asio::io_context& ctx)
-      : id_(uuid::random())
+      : id_(uuid::to_string(uuid::random()))
       , ctx_(ctx)
       , work_(asio::make_work_guard(ctx_))
-      , session_(std::make_shared<io::mcbp_session>(id_, ctx_))
-      , session_manager_(std::make_shared<io::session_manager>(id_, ctx_))
-    {
-    }
-
-    ~cluster()
+      , tls_(asio::ssl::context::tls_client)
+      , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_, tls_))
+      , dns_config_(io::dns::dns_config::get())
+      , dns_client_(ctx_)
     {
-        work_.reset();
     }
 
     template<typename Handler>
     void open(const couchbase::origin& origin, Handler&& handler)
     {
-        auto address = origin.get_address();
         origin_ = origin;
-        session_->bootstrap(address.first,
-                            address.second,
-                            origin.get_username(),
-                            origin.get_password(),
-                            [this, handler = std::forward<Handler>(handler)](std::error_code ec, configuration config) mutable {
-                                session_manager_->set_configuration(config);
-                                handler(ec);
-                            });
+        if (origin_.options().enable_dns_srv) {
+            return asio::post(asio::bind_executor(
+              ctx_, [this, handler = std::forward<Handler>(handler)]() mutable { return do_dns_srv(std::forward<Handler>(handler)); }));
+        }
+        do_open(std::forward<Handler>(handler));
     }
 
     template<typename Handler>
     void close(Handler&& handler)
     {
         asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
-            session_->stop();
+            if (session_) {
+                session_->stop(io::retry_reason::do_not_retry);
+            }
             for (auto& bucket : buckets_) {
                 bucket.second->close();
             }
             handler();
+            work_.reset();
         }));
     }
 
     template<typename Handler>
     void open_bucket(const std::string& bucket_name, Handler&& handler)
     {
-        if (!session_->has_config()) {
-            return handler(std::make_error_code(error::common_errc::invalid_argument));
+        std::vector<protocol::hello_feature> known_features;
+        if (session_ && session_->has_config()) {
+            known_features = session_->supported_features();
         }
-        configuration config = session_->config();
-        auto& node = config.nodes.front();
-        auto new_session = std::make_shared<io::mcbp_session>(id_, ctx_, bucket_name);
-        new_session->bootstrap(
-          node.hostname,
-          std::to_string(*node.services_plain.key_value),
-          origin_.get_username(),
-          origin_.get_password(),
-          [this, name = bucket_name, new_session, h = std::forward<Handler>(handler)](std::error_code ec, configuration cfg) mutable {
-              if (!ec) {
-                  if (!session_->supports_gcccp()) {
-                      session_manager_->set_configuration(cfg);
-                  }
-                  auto b = std::make_shared<bucket>(ctx_, name, cfg);
-                  size_t this_index = new_session->index();
-                  b->set_node(this_index, new_session);
-                  if (cfg.nodes.size() > 1) {
-                      for (const auto& n : cfg.nodes) {
-                          if (n.index != this_index) {
-                              auto s = std::make_shared<io::mcbp_session>(id_, ctx_, name);
-                              b->set_node(n.index, s);
-                              s->bootstrap(n.hostname,
-                                           std::to_string(*n.services_plain.key_value),
-                                           origin_.get_username(),
-                                           origin_.get_password(),
-                                           [s, i = n.index, b](std::error_code err, configuration /*config*/) {
-                                               if (err) {
-                                                   spdlog::warn("unable to bootstrap node: {}", err.message());
-                                                   b->remove_node(i);
-                                               }
-                                           });
-                          }
-                      }
-                  }
-                  buckets_.emplace(name, std::move(b));
-              }
-              h(ec);
-          });
+        auto b = std::make_shared<bucket>(id_, ctx_, tls_, bucket_name, origin_, known_features);
+        b->bootstrap([this, handler = std::forward<Handler>(handler)](std::error_code ec, const configuration& config) mutable {
+            if (!ec && !session_->supports_gcccp()) {
+                session_manager_->set_configuration(config, origin_.options());
+            }
+            handler(ec);
+        });
+        buckets_.emplace(bucket_name, b);
     }
 
     template<class Request, class Handler>
@@ -152,11 +104,11 @@ class cluster
     template<class Request, class Handler>
     void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_->check_out(Request::type, origin_.username, origin_.password);
+        auto session = session_manager_->check_out(Request::type, origin_.credentials());
         if (!session) {
             return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
         }
-        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
+        auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request);
         cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {
             handler(std::move(resp));
             session_manager_->check_in(Request::type, session);
@@ -164,12 +116,120 @@ class cluster
     }
 
   private:
-    uuid::uuid_t id_;
+    template<typename Handler>
+    void do_dns_srv(Handler&& handler)
+    {
+        std::string hostname;
+        std::string service;
+        std::tie(hostname, service) = origin_.next_address();
+        service = origin_.options().enable_tls ? "_couchbases" : "_couchbase";
+        dns_client_.query_srv(
+          hostname,
+          service,
+          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response resp) mutable {
+              if (resp.ec) {
+                  spdlog::warn("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",
+                               hostname,
+                               resp.ec.message());
+              } else if (resp.targets.empty()) {
+                  spdlog::warn("DNS SRV query returned 0 records for \"{}\", assuming that cluster is listening this address", hostname);
+              } else {
+                  origin::node_list nodes;
+                  nodes.reserve(resp.targets.size());
+                  for (const auto& address : resp.targets) {
+                      origin::node_entry node;
+                      node.first = address.hostname;
+                      node.second = std::to_string(address.port);
+                      nodes.emplace_back(node);
+                  }
+                  origin_.set_nodes(nodes);
+                  spdlog::info("replace list of bootstrap nodes with addresses from DNS SRV of \"{}\": [{}]",
+                               hostname,
+                               fmt::join(origin_.get_nodes(), ", "));
+              }
+              return do_open(std::forward<Handler>(handler));
+          });
+    }
+
+    template<typename Handler>
+    void do_open(Handler&& handler)
+    {
+        if (origin_.options().enable_tls) {
+            tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
+            if (!origin_.options().trust_certificate.empty()) {
+                std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate chain: "{}")", id_, origin_.options().trust_certificate);
+                tls_.use_certificate_chain_file(origin_.options().trust_certificate, ec);
+                if (ec) {
+                    spdlog::error(
+                      "[{}]: unable to load certificate chain \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
+                    return handler(ec);
+                }
+            }
+#ifdef TLS_KEY_LOG_FILE
+            SSL_CTX_set_keylog_callback(tls_.native_handle(), [](const SSL* /* ssl */, const char* line) {
+                std::ofstream keylog(TLS_KEY_LOG_FILE, std::ios::out | std::ios::app | std::ios::binary);
+                keylog << std::string_view(line) << std::endl;
+            });
+            spdlog::critical("TLS_KEY_LOG_FILE was set to \"{}\" during build, all TLS keys will be logged for network analysis "
+                             "(https://wiki.wireshark.org/TLS). DO NOT USE THIS BUILD IN PRODUCTION",
+                             TLS_KEY_LOG_FILE);
+#endif
+            if (origin_.credentials().uses_certificate()) {
+                std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate: "{}")", id_, origin_.certificate_path());
+                tls_.use_certificate_file(origin_.certificate_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load certificate \"{}\": {}", id_, origin_.certificate_path(), ec.message());
+                    return handler(ec);
+                }
+                spdlog::debug(R"([{}]: use TLS private key: "{}")", id_, origin_.key_path());
+                tls_.use_private_key_file(origin_.key_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load private key \"{}\": {}", id_, origin_.key_path(), ec.message());
+                    return handler(ec);
+                }
+            }
+            session_ = std::make_shared<io::mcbp_session>(id_, ctx_, tls_, origin_);
+        } else {
+            session_ = std::make_shared<io::mcbp_session>(id_, ctx_, origin_);
+        }
+        session_->bootstrap([this, handler = std::forward<Handler>(handler)](std::error_code ec, const configuration& config) mutable {
+            if (!ec) {
+                if (origin_.options().network == "auto") {
+                    origin_.options().network = config.select_network(session_->bootstrap_hostname());
+                    spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                }
+                if (origin_.options().network != "default") {
+                    origin::node_list nodes;
+                    nodes.reserve(config.nodes.size());
+                    for (const auto& address : config.nodes) {
+                        origin::node_entry node;
+                        node.first = address.hostname_for(origin_.options().network);
+                        node.second =
+                          std::to_string(address.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0));
+                        nodes.emplace_back(node);
+                    }
+                    origin_.set_nodes(nodes);
+                    spdlog::info("replace list of bootstrap nodes with addresses of alternative network \"{}\": [{}]",
+                                 origin_.options().network,
+                                 fmt::join(origin_.get_nodes(), ","));
+                }
+                session_manager_->set_configuration(config, origin_.options());
+            }
+            handler(ec);
+        });
+    }
+
+    std::string id_;
     asio::io_context& ctx_;
     asio::executor_work_guard<asio::io_context::executor_type> work_;
-    std::shared_ptr<io::mcbp_session> session_;
-    std::shared_ptr<io::session_manager> session_manager_;
-    std::map<std::string, std::shared_ptr<bucket>> buckets_;
-    origin origin_;
+    asio::ssl::context tls_;
+    std::shared_ptr<io::http_session_manager> session_manager_;
+    io::dns::dns_config& dns_config_;
+    couchbase::io::dns::dns_client dns_client_;
+    std::shared_ptr<io::mcbp_session> session_{};
+    std::map<std::string, std::shared_ptr<bucket>> buckets_{};
+    couchbase::origin origin_{};
 };
 } // namespace couchbase

data/ext/couchbase/cluster_options.hxx

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#pragma once
+
+#include <timeout_defaults.hxx>
+
+namespace couchbase
+{
+struct cluster_options {
+    std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
+    std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
+    std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
+    std::chrono::milliseconds key_value_durable_timeout = timeout_defaults::key_value_durable_timeout;
+    std::chrono::milliseconds view_timeout = timeout_defaults::view_timeout;
+    std::chrono::milliseconds query_timeout = timeout_defaults::query_timeout;
+    std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
+    std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
+    std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
+    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
+
+    bool enable_tls{ false };
+    std::string trust_certificate{};
+    bool enable_mutation_tokens{ true };
+    bool enable_tcp_keep_alive{ true };
+    bool force_ipv4{ false };
+    bool enable_dns_srv{ true };
+    std::string network{ "auto" };
+
+    std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;
+    std::chrono::milliseconds config_poll_interval = timeout_defaults::config_poll_interval;
+    std::chrono::milliseconds config_poll_floor = timeout_defaults::config_poll_floor;
+    std::chrono::milliseconds config_idle_redial_timeout = timeout_defaults::config_idle_redial_timeout;
+
+    size_t max_http_connections{ 0 };
+    std::chrono::milliseconds idle_http_connection_timeout = timeout_defaults::idle_http_connection_timeout;
+};
+
+} // namespace couchbase

data/ext/couchbase/configuration.hxx

@@ -24,25 +24,162 @@
 #include <utils/crc32.hxx>
 #include <platform/uuid.h>
 
+#include <service_type.hxx>
+
 namespace couchbase
 {
 struct configuration {
     struct port_map {
-        std::optional<std::uint16_t> key_value;
-        std::optional<std::uint16_t> management;
-        std::optional<std::uint16_t> analytics;
-        std::optional<std::uint16_t> search;
-        std::optional<std::uint16_t> views;
-        std::optional<std::uint16_t> query;
+        std::optional<std::uint16_t> key_value{};
+        std::optional<std::uint16_t> management{};
+        std::optional<std::uint16_t> analytics{};
+        std::optional<std::uint16_t> search{};
+        std::optional<std::uint16_t> views{};
+        std::optional<std::uint16_t> query{};
+    };
+    struct alternate_address {
+        std::string name{};
+        std::string hostname{};
+        port_map services_plain{};
+        port_map services_tls{};
     };
     struct node {
         bool this_node{ false };
-        size_t index;
-        std::string hostname;
-        port_map services_plain;
-        port_map services_tls;
+        size_t index{};
+        std::string hostname{};
+        port_map services_plain{};
+        port_map services_tls{};
+        std::map<std::string, alternate_address> alt{};
+
+        [[nodiscard]] std::uint16_t port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+        {
+            if (is_tls) {
+                switch (type) {
+                    case service_type::query:
+                        return services_tls.query.value_or(default_value);
+
+                    case service_type::analytics:
+                        return services_tls.analytics.value_or(default_value);
+
+                    case service_type::search:
+                        return services_tls.search.value_or(default_value);
+
+                    case service_type::views:
+                        return services_tls.views.value_or(default_value);
+
+                    case service_type::management:
+                        return services_tls.management.value_or(default_value);
+
+                    case service_type::kv:
+                        return services_tls.key_value.value_or(default_value);
+                }
+            }
+            switch (type) {
+                case service_type::query:
+                    return services_plain.query.value_or(default_value);
+
+                case service_type::analytics:
+                    return services_plain.analytics.value_or(default_value);
+
+                case service_type::search:
+                    return services_plain.search.value_or(default_value);
+
+                case service_type::views:
+                    return services_plain.views.value_or(default_value);
+
+                case service_type::management:
+                    return services_plain.management.value_or(default_value);
+
+                case service_type::kv:
+                    return services_plain.key_value.value_or(default_value);
+            }
+            return default_value;
+        }
+
+        [[nodiscard]] const std::string & hostname_for(const std::string& network) const
+        {
+            if (network == "default") {
+                return hostname;
+            }
+            const auto& address = alt.find(network);
+            if (address == alt.end()) {
+                spdlog::warn(R"(requested network "{}" is not found, fallback to "default" host)", network);
+                return hostname;
+            }
+            return address->second.hostname;
+        }
+
+        [[nodiscard]] std::uint16_t port_or(const std::string& network, service_type type, bool is_tls, std::uint16_t default_value) const
+        {
+            if (network == "default") {
+                return port_or(type, is_tls, default_value);
+            }
+            const auto& address = alt.find(network);
+            if (address == alt.end()) {
+                spdlog::warn(R"(requested network "{}" is not found, fallback to "default" port of {} service)", network, type);
+                return port_or(type, is_tls, default_value);
+            }
+            if (is_tls) {
+                switch (type) {
+                    case service_type::query:
+                        return address->second.services_tls.query.value_or(default_value);
+
+                    case service_type::analytics:
+                        return address->second.services_tls.analytics.value_or(default_value);
+
+                    case service_type::search:
+                        return address->second.services_tls.search.value_or(default_value);
+
+                    case service_type::views:
+                        return address->second.services_tls.views.value_or(default_value);
+
+                    case service_type::management:
+                        return address->second.services_tls.management.value_or(default_value);
+
+                    case service_type::kv:
+                        return address->second.services_tls.key_value.value_or(default_value);
+                }
+            }
+            switch (type) {
+                case service_type::query:
+                    return address->second.services_plain.query.value_or(default_value);
+
+                case service_type::analytics:
+                    return address->second.services_plain.analytics.value_or(default_value);
+
+                case service_type::search:
+                    return address->second.services_plain.search.value_or(default_value);
+
+                case service_type::views:
+                    return address->second.services_plain.views.value_or(default_value);
+
+                case service_type::management:
+                    return address->second.services_plain.management.value_or(default_value);
+
+                case service_type::kv:
+                    return address->second.services_plain.key_value.value_or(default_value);
+            }
+            return default_value;
+        }
     };
 
+    [[nodiscard]] std::string select_network(const std::string& bootstrap_hostname) const
+    {
+        for (const auto& n : nodes) {
+            if (n.this_node) {
+                if (n.hostname == bootstrap_hostname) {
+                    return "default";
+                }
+                for (const auto& entry : n.alt) {
+                    if (entry.second.hostname == bootstrap_hostname) {
+                        return entry.first;
+                    }
+                }
+            }
+        }
+        return "default";
+    }
+
     using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
     std::uint64_t rev{};
@@ -74,14 +211,14 @@ struct configuration {
         throw std::runtime_error("no nodes marked as this_node");
     }
 
-    std::pair<uint16_t, size_t> map_key(const std::string& key)
+    std::pair<std::uint16_t, std::int16_t> map_key(const std::string& key)
     {
         if (!vbmap.has_value()) {
             throw std::runtime_error("cannot map key: partition map is not available");
         }
         uint32_t crc = utils::hash_crc32(key.data(), key.size());
         uint16_t vbucket = uint16_t(crc % vbmap->size());
-        return std::make_pair(vbucket, static_cast<std::size_t>(vbmap->at(vbucket)[0]));
+        return std::make_pair(vbucket, vbmap->at(vbucket)[0]);
     }
 };
 
@@ -143,12 +280,69 @@ struct fmt::formatter<couchbase::configuration::node> : formatter<std::string> {
         if (node.services_tls.views) {
             tls.push_back(fmt::format("capi={}", *node.services_tls.views));
         }
+        std::vector<std::string> alternate_addresses{};
+        if (!node.alt.empty()) {
+            alternate_addresses.reserve(node.alt.size());
+            for (const auto& entry : node.alt) {
+                std::string network = fmt::format(R"(name="{}", host="{}")", entry.second.name, entry.second.hostname);
+                {
+                    std::vector<std::string> ports;
+                    if (entry.second.services_plain.key_value) {
+                        ports.push_back(fmt::format("kv={}", *entry.second.services_plain.key_value));
+                    }
+                    if (entry.second.services_plain.management) {
+                        ports.push_back(fmt::format("mgmt={}", *entry.second.services_plain.management));
+                    }
+                    if (entry.second.services_plain.analytics) {
+                        ports.push_back(fmt::format("cbas={}", *entry.second.services_plain.analytics));
+                    }
+                    if (entry.second.services_plain.search) {
+                        ports.push_back(fmt::format("fts={}", *entry.second.services_plain.search));
+                    }
+                    if (entry.second.services_plain.query) {
+                        ports.push_back(fmt::format("n1ql={}", *entry.second.services_plain.query));
+                    }
+                    if (entry.second.services_plain.views) {
+                        ports.push_back(fmt::format("capi={}", *entry.second.services_plain.views));
+                    }
+                    if (!ports.empty()) {
+                        network += fmt::format(", plain=({})", fmt::join(ports, ","));
+                    }
+                }
+                {
+                    std::vector<std::string> ports;
+                    if (entry.second.services_tls.key_value) {
+                        ports.push_back(fmt::format("kv={}", *entry.second.services_tls.key_value));
+                    }
+                    if (entry.second.services_tls.management) {
+                        ports.push_back(fmt::format("mgmt={}", *entry.second.services_tls.management));
+                    }
+                    if (entry.second.services_tls.analytics) {
+                        ports.push_back(fmt::format("cbas={}", *entry.second.services_tls.analytics));
+                    }
+                    if (entry.second.services_tls.search) {
+                        ports.push_back(fmt::format("fts={}", *entry.second.services_tls.search));
+                    }
+                    if (entry.second.services_tls.query) {
+                        ports.push_back(fmt::format("n1ql={}", *entry.second.services_tls.query));
+                    }
+                    if (entry.second.services_tls.views) {
+                        ports.push_back(fmt::format("capi={}", *entry.second.services_tls.views));
+                    }
+                    if (!ports.empty()) {
+                        network += fmt::format(", tls=({})", fmt::join(ports, ","));
+                    }
+                }
+                alternate_addresses.emplace_back(network);
+            }
+        }
         format_to(ctx.out(),
-                  R"(#<node:{} hostname={}, plain=({}), tls=({})>)",
+                  R"(#<node:{} hostname="{}", plain=({}), tls=({}), alt=[{}]>)",
                   node.index,
                   node.hostname,
                   fmt::join(plain, ", "),
-                  fmt::join(tls, ", "));
+                  fmt::join(tls, ", "),
+                  fmt::join(alternate_addresses, ", "));
         return formatter<std::string>::format("", ctx);
     }
 };
@@ -208,6 +402,30 @@ struct traits<couchbase::configuration> {
             n.services_tls.analytics = s.template optional<std::uint16_t>("cbasSSL");
             n.services_tls.query = s.template optional<std::uint16_t>("n1qlSSL");
             n.services_tls.views = s.template optional<std::uint16_t>("capiSSL");
+            {
+                const auto& alt = o.find("alternateAddresses");
+                if (alt != o.end()) {
+                    for (const auto& entry : alt->second.get_object()) {
+                        couchbase::configuration::alternate_address addr;
+                        addr.name = entry.first;
+                        addr.hostname = entry.second.at("hostname").get_string();
+                        const auto& ports = entry.second.find("ports");
+                        addr.services_plain.key_value = ports->template optional<std::uint16_t>("kv");
+                        addr.services_plain.management = ports->template optional<std::uint16_t>("mgmt");
+                        addr.services_plain.search = ports->template optional<std::uint16_t>("fts");
+                        addr.services_plain.analytics = ports->template optional<std::uint16_t>("cbas");
+                        addr.services_plain.query = ports->template optional<std::uint16_t>("n1ql");
+                        addr.services_plain.views = ports->template optional<std::uint16_t>("capi");
+                        addr.services_tls.key_value = ports->template optional<std::uint16_t>("kvSSL");
+                        addr.services_tls.management = ports->template optional<std::uint16_t>("mgmtSSL");
+                        addr.services_tls.search = ports->template optional<std::uint16_t>("ftsSSL");
+                        addr.services_tls.analytics = ports->template optional<std::uint16_t>("cbasSSL");
+                        addr.services_tls.query = ports->template optional<std::uint16_t>("n1qlSSL");
+                        addr.services_tls.views = ports->template optional<std::uint16_t>("capiSSL");
+                        n.alt.emplace(entry.first, addr);
+                    }
+                }
+            }
             result.nodes.emplace_back(n);
         }
         {