Add new capabilities to C++

3 files changed, 127 insertions, 16 deletions

diff --git a/vespalib/src/tests/net/tls/capabilities/capabilities_test.cpp b/vespalib/src/tests/net/tls/capabilities/capabilities_test.cpp
index 3bc03fbe5b9..1180867ba92 100644
--- a/vespalib/src/tests/net/tls/capabilities/capabilities_test.cpp
+++ b/vespalib/src/tests/net/tls/capabilities/capabilities_test.cpp
@@ -37,20 +37,6 @@ TEST("CapabilitySet instances are equality comparable") {
     EXPECT_NOT_EQUAL(set_1, empty);
 }
 
-TEST("Can get underlying name of all Capability instances") {
-    EXPECT_EQUAL(Capability::none().name(),                     "vespa.none"sv);
-    EXPECT_EQUAL(Capability::content_storage_api().name(),      "vespa.content.storage_api"sv);
-    EXPECT_EQUAL(Capability::content_document_api().name(),     "vespa.content.document_api"sv);
-    EXPECT_EQUAL(Capability::content_search_api().name(),       "vespa.content.search_api"sv);
-    EXPECT_EQUAL(Capability::content_proton_admin_api().name(), "vespa.content.proton_admin_api"sv);
-    EXPECT_EQUAL(Capability::slobrok_api().name(),              "vespa.slobrok.api"sv);
-    EXPECT_EQUAL(Capability::config_sentinel_api().name(),      "vespa.config.sentinel_api"sv);
-    EXPECT_EQUAL(Capability::content_status_pages().name(),     "vespa.content.status_pages"sv);
-    EXPECT_EQUAL(Capability::content_metrics_api().name(),      "vespa.content.metrics_api"sv);
-    EXPECT_EQUAL(Capability::content_cluster_controller_internal_state_api().name(),
-                 "vespa.content.cluster_controller.internal_state_api"sv);
-}
-
 TEST("Capability instances can be stringified") {
     EXPECT_EQUAL(Capability::content_storage_api().to_string(), "Capability(vespa.content.storage_api)");
 }
@@ -61,6 +47,7 @@ void check_capability_mapping(const std::string& name, Capability expected) {
     auto cap = Capability::find_capability(name);
     ASSERT_TRUE(cap.has_value());
     EXPECT_EQUAL(*cap, expected);
+    EXPECT_EQUAL(name, cap->name());
 }
 
 void check_capability_set_mapping(const std::string& name, CapabilitySet expected) {
@@ -71,8 +58,23 @@ void check_capability_set_mapping(const std::string& name, CapabilitySet expecte
 
 }
 
-TEST("All known capabilities can be looked up by name") {
+TEST("All known capabilities can be looked up by name, and resolve back to same name") {
     check_capability_mapping("vespa.none",                     Capability::none());
+    check_capability_mapping("vespa.http.unclassified",        Capability::http_unclassified());
+    check_capability_mapping("vespa.restapi.unclassified",     Capability::restapi_unclassified());
+    check_capability_mapping("vespa.rpc.unclassified",         Capability::rpc_unclassified());
+    check_capability_mapping("vespa.client.filereceiver_api",  Capability::client_filereceiver_api());
+    check_capability_mapping("vespa.client.slobrok_api",       Capability::client_slobrok_api());
+    check_capability_mapping("vespa.configproxy.config_api",   Capability::configproxy_config_api());
+    check_capability_mapping("vespa.configproxy.management_api",
+                             Capability::configproxy_management_api());
+    check_capability_mapping("vespa.configproxy.filedistribution_api",
+                             Capability::configproxy_filedistribution_api());
+    check_capability_mapping("vespa.configserver.config_api",  Capability::configserver_config_api());
+    check_capability_mapping("vespa.configserver.filedistribution_api",
+                             Capability::configserver_filedistribution_api());
+    check_capability_mapping("vespa.container.document_api",   Capability::container_document_api());
+    check_capability_mapping("vespa.container.management_api", Capability::container_management_api());
     check_capability_mapping("vespa.content.storage_api",      Capability::content_storage_api());
     check_capability_mapping("vespa.content.document_api",     Capability::content_document_api());
     check_capability_mapping("vespa.content.search_api",       Capability::content_search_api());
@@ -83,6 +85,10 @@ TEST("All known capabilities can be looked up by name") {
     check_capability_mapping("vespa.content.metrics_api",      Capability::content_metrics_api());
     check_capability_mapping("vespa.content.cluster_controller.internal_state_api",
                              Capability::content_cluster_controller_internal_state_api());
+    check_capability_mapping("vespa.logserver.api",            Capability::logserver_api());
+    check_capability_mapping("vespa.metricsproxy.management_api",
+                             Capability::metricsproxy_management_api());
+    check_capability_mapping("vespa.metricsproxy.metrics_api", Capability::metricsproxy_metrics_api());
 }
 
 TEST("Unknown capability name returns nullopt") {
diff --git a/vespalib/src/vespa/vespalib/net/tls/capability.cpp b/vespalib/src/vespa/vespalib/net/tls/capability.cpp
index d634eda9db6..91fb1cf18ef 100644
--- a/vespalib/src/vespa/vespalib/net/tls/capability.cpp
+++ b/vespalib/src/vespa/vespalib/net/tls/capability.cpp
@@ -14,6 +14,18 @@ using namespace std::string_view_literals;
 // Important: must match 1-1 with CapabilityId values!
 constexpr std::array<std::string_view, Capability::max_value_count()> capability_names = {
     "vespa.none"sv,
+    "vespa.http.unclassified"sv,
+    "vespa.restapi.unclassified"sv,
+    "vespa.rpc.unclassified"sv,
+    "vespa.client.filereceiver_api"sv,
+    "vespa.client.slobrok_api"sv,
+    "vespa.configproxy.config_api"sv,
+    "vespa.configproxy.management_api"sv,
+    "vespa.configproxy.filedistribution_api"sv,
+    "vespa.configserver.config_api"sv,
+    "vespa.configserver.filedistribution_api"sv,
+    "vespa.container.document_api"sv,
+    "vespa.container.management_api"sv,
     "vespa.content.storage_api"sv,
     "vespa.content.document_api"sv,
     "vespa.content.search_api"sv,
@@ -23,6 +35,9 @@ constexpr std::array<std::string_view, Capability::max_value_count()> capability
     "vespa.config.sentinel_api"sv,
     "vespa.content.status_pages"sv,
     "vespa.content.metrics_api"sv,
+    "vespa.logserver.api"sv,
+    "vespa.metricsproxy.management_api"sv,
+    "vespa.metricsproxy.metrics_api"sv,
 };
 
 } // anon ns
@@ -41,6 +56,18 @@ string Capability::to_string() const {
 std::optional<Capability> Capability::find_capability(const string& cap_name) noexcept {
     static const hash_map<string, Capability> name_to_cap({
         {"vespa.none",                                          none()},
+        {"vespa.http.unclassified",                             http_unclassified()},
+        {"vespa.restapi.unclassified",                          restapi_unclassified()},
+        {"vespa.rpc.unclassified",                              rpc_unclassified()},
+        {"vespa.client.filereceiver_api",                       client_filereceiver_api()},
+        {"vespa.client.slobrok_api",                            client_slobrok_api()},
+        {"vespa.configproxy.config_api",                        configproxy_config_api()},
+        {"vespa.configproxy.management_api",                    configproxy_management_api()},
+        {"vespa.configproxy.filedistribution_api",              configproxy_filedistribution_api()},
+        {"vespa.configserver.config_api",                       configserver_config_api()},
+        {"vespa.configserver.filedistribution_api",             configserver_filedistribution_api()},
+        {"vespa.container.document_api",                        container_document_api()},
+        {"vespa.container.management_api",                      container_management_api()},
         {"vespa.content.storage_api",                           content_storage_api()},
         {"vespa.content.document_api",                          content_document_api()},
         {"vespa.content.search_api",                            content_search_api()},
@@ -50,6 +77,9 @@ std::optional<Capability> Capability::find_capability(const string& cap_name) no
         {"vespa.config.sentinel_api",                           config_sentinel_api()},
         {"vespa.content.status_pages",                          content_status_pages()},
         {"vespa.content.metrics_api",                           content_metrics_api()},
+        {"vespa.logserver.api",                                 logserver_api()},
+        {"vespa.metricsproxy.management_api",                   metricsproxy_management_api()},
+        {"vespa.metricsproxy.metrics_api",                      metricsproxy_metrics_api()},
     });
     auto iter = name_to_cap.find(cap_name);
     return (iter != name_to_cap.end()) ? std::optional<Capability>(iter->second) : std::nullopt;
diff --git a/vespalib/src/vespa/vespalib/net/tls/capability.h b/vespalib/src/vespa/vespalib/net/tls/capability.h
index 0a980ee32ee..ff49869689d 100644
--- a/vespalib/src/vespa/vespalib/net/tls/capability.h
+++ b/vespalib/src/vespa/vespalib/net/tls/capability.h
@@ -26,6 +26,18 @@ private:
     // Changes must be reflected in capabilities_test.cpp
     enum class Id : uint32_t {
         None = 0, // Must start at zero
+        HttpUnclassified,
+        RestApiUnclassified,
+        RpcUnclassified,
+        ClientFilereceiverApi,
+        ClientSlobrokApi,
+        ConfigproxyConfigApi,
+        ConfigproxyManagementApi,
+        ConfigproxyFiledistributionApi,
+        ConfigserverConfigApi,
+        ConfigserverFiledistributionApi,
+        ContainerDocumentApi,
+        ContainerManagementApi,
         ContentStorageApi,
         ContentDocumentApi,
         ContentSearchApi,
@@ -35,12 +47,15 @@ private:
         ConfigSentinelApi,
         ContentStatusPages,
         ContentMetricsApi,
+        LogserverApi,
+        MetricsproxyManagementApi,
+        MetricsproxyMetricsApi,
         // When adding a capability ID to the end, max_value_count() MUST be updated
     };
 public:
     constexpr static size_t max_value_count() noexcept {
         // This must refer to the highest possible CapabilityId enum value.
-        return static_cast<size_t>(Id::ContentMetricsApi) + 1;
+        return static_cast<size_t>(Id::MetricsproxyMetricsApi) + 1;
     }
 private:
     Id _cap_id;
@@ -79,6 +94,54 @@ public:
         return Capability(Id::None);
     }
 
+    constexpr static Capability http_unclassified() noexcept {
+        return Capability(Id::HttpUnclassified);
+    }
+
+    constexpr static Capability restapi_unclassified() noexcept {
+        return Capability(Id::RestApiUnclassified);
+    }
+
+    constexpr static Capability rpc_unclassified() noexcept {
+        return Capability(Id::RpcUnclassified);
+    }
+
+    constexpr static Capability client_filereceiver_api() noexcept {
+        return Capability(Id::ClientFilereceiverApi);
+    }
+
+    constexpr static Capability client_slobrok_api() noexcept {
+        return Capability(Id::ClientSlobrokApi);
+    }
+
+    constexpr static Capability configproxy_config_api() noexcept {
+        return Capability(Id::ConfigproxyConfigApi);
+    }
+
+    constexpr static Capability configproxy_management_api() noexcept {
+        return Capability(Id::ConfigproxyManagementApi);
+    }
+
+    constexpr static Capability configproxy_filedistribution_api() noexcept {
+        return Capability(Id::ConfigproxyFiledistributionApi);
+    }
+
+    constexpr static Capability configserver_config_api() noexcept {
+        return Capability(Id::ConfigserverConfigApi);
+    }
+
+    constexpr static Capability configserver_filedistribution_api() noexcept {
+        return Capability(Id::ConfigserverFiledistributionApi);
+    }
+
+    constexpr static Capability container_document_api() noexcept {
+        return Capability(Id::ContainerDocumentApi);
+    }
+
+    constexpr static Capability container_management_api() noexcept {
+        return Capability(Id::ContainerManagementApi);
+    }
+
     constexpr static Capability content_storage_api() noexcept {
         return Capability(Id::ContentStorageApi);
     }
@@ -115,6 +178,18 @@ public:
         return Capability(Id::ContentMetricsApi);
     }
 
+    constexpr static Capability logserver_api() noexcept {
+        return Capability(Id::LogserverApi);
+    }
+
+    constexpr static Capability metricsproxy_management_api() noexcept {
+        return Capability(Id::MetricsproxyManagementApi);
+    }
+
+    constexpr static Capability metricsproxy_metrics_api() noexcept {
+        return Capability(Id::MetricsproxyMetricsApi);
+    }
+
 };
 
 std::ostream& operator<<(std::ostream&, const Capability& cap);