couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/cluster.hxx

@@ -19,111 +19,75 @@
 
 #include <utility>
 #include <thread>
+#include <fstream>
 
-#include <io/key_value_session.hxx>
-#include <io/session_manager.hxx>
+#include <asio/ssl.hpp>
+
+#include <io/mcbp_session.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/query.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::key_value_session>(id_, ctx_))
-      , session_manager_(id_, ctx_)
+      , 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_)
     {
     }
 
-    ~cluster()
-    {
-        work_.reset();
-        close();
-    }
-
     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(), std::forward<Handler>(handler));
-        session_->subscribe_to_configuration_updates([this](const configuration& config) { session_manager_.set_configuration(config); });
+        if (origin_.options().enable_dns_srv) {
+            return do_dns_srv(std::forward<Handler>(handler));
+        }
+        do_open(std::forward<Handler>(handler));
     }
 
-    void close()
+    template<typename Handler>
+    void close(Handler&& handler)
     {
-        session_->stop();
-        for (auto& bucket : buckets_) {
-            bucket.second.close();
-        }
+        asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
+            if (session_) {
+                session_->stop();
+            }
+            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::key_value_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) mutable {
-                                   if (!ec) {
-                                       bucket b(ctx_, name, new_session->config());
-                                       size_t this_index = new_session->index();
-                                       if (new_session->config().nodes.size() > 1) {
-                                           for (const auto& n : new_session->config().nodes) {
-                                               if (n.index != this_index) {
-                                                   auto s = std::make_shared<io::key_value_session>(id_, ctx_, name);
-                                                   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) {
-                                                                    if (err) {
-                                                                        spdlog::warn("unable to bootstrap node: {}", err.message());
-                                                                    } else {
-                                                                        b.set_node(i, s);
-                                                                    }
-                                                                });
-                                               }
-                                           }
-                                       }
-                                       b.set_node(this_index, std::move(new_session));
-                                       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>
@@ -133,27 +97,121 @@ class cluster
         if (bucket == buckets_.end()) {
             return handler(operations::make_response(std::make_error_code(error::common_errc::bucket_not_found), request, {}));
         }
-        return bucket->second.execute(request, std::forward<Handler>(handler));
+        return bucket->second->execute(request, std::forward<Handler>(handler));
     }
 
-    template<class Handler>
-    void execute(operations::query_request request, Handler&& handler)
+    template<class Request, class Handler>
+    void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_.check_out(service_type::query, origin_.username, origin_.password);
-        auto cmd = std::make_shared<operations::command<operations::query_request>>(ctx_, std::move(request));
-        cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](operations::query_response resp) mutable {
+        auto session = session_manager_->check_out(Request::type, origin_.get_username(), origin_.get_password());
+        if (!session) {
+            return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), 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(service_type::query, session);
+            session_manager_->check_in(Request::type, session);
         });
     }
 
   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{};
+                tls_.use_certificate_chain_file(origin_.options().trust_certificate, ec);
+                if (ec) {
+                    spdlog::error("unable to load certificate chain \"{}\": {}", 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
+            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::key_value_session> session_;
-    io::session_manager session_manager_;
-    std::map<std::string, 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
+} // 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/collections_manifest.hxx

@@ -69,14 +69,14 @@ struct traits<couchbase::collections_manifest> {
         (void)v;
         couchbase::collections_manifest result;
         result.id = couchbase::uuid::random();
-        result.uid = std::stoull(v.at("uid").get_string());
+        result.uid = std::stoull(v.at("uid").get_string(), 0, 16);
         for (const auto& s : v.at("scopes").get_array()) {
             couchbase::collections_manifest::scope scope;
-            scope.uid = std::stoull(s.at("uid").get_string());
+            scope.uid = std::stoull(s.at("uid").get_string(), 0, 16);
             scope.name = s.at("name").get_string();
             for (const auto& c : s.at("collections").get_array()) {
                 couchbase::collections_manifest::collection collection;
-                collection.uid = std::stoull(c.at("uid").get_string());
+                collection.uid = std::stoull(c.at("uid").get_string(), 0, 16);
                 collection.name = c.at("name").get_string();
                 scope.collections.emplace_back(collection);
             }

data/ext/couchbase/configuration.hxx

@@ -24,6 +24,8 @@
 #include <utils/crc32.hxx>
 #include <platform/uuid.h>
 
+#include <service_type.hxx>
+
 namespace couchbase
 {
 struct configuration {
@@ -35,14 +37,149 @@ struct configuration {
         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;
+        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{};
@@ -84,6 +221,20 @@ struct configuration {
         return std::make_pair(vbucket, static_cast<std::size_t>(vbmap->at(vbucket)[0]));
     }
 };
+
+configuration
+make_blank_configuration(const std::string& hostname, std::uint16_t plain_port, std::uint16_t tls_port)
+{
+    configuration result;
+    result.id = couchbase::uuid::random();
+    result.rev = 0;
+    result.nodes.resize(1);
+    result.nodes[0].hostname = hostname;
+    result.nodes[0].this_node = true;
+    result.nodes[0].services_plain.key_value = plain_port;
+    result.nodes[0].services_tls.key_value = tls_port;
+    return result;
+}
 } // namespace couchbase
 
 template<>
@@ -129,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);
     }
 };
@@ -194,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);
         }
         {