From 2b392bf27a0c683bb9aa42941a00524b20420de7 Mon Sep 17 00:00:00 2001 From: Scott Hart Date: Thu, 5 Feb 2026 13:24:16 -0500 Subject: [PATCH 1/6] feat(apiregistry): generate library --- external/googleapis/update_libraries.sh | 1 + generator/generator_config.textproto | 8 ++++++++ 2 files changed, 9 insertions(+) diff --git a/external/googleapis/update_libraries.sh b/external/googleapis/update_libraries.sh index 7efb27865b864..b4c1ac67dc04e 100755 --- a/external/googleapis/update_libraries.sh +++ b/external/googleapis/update_libraries.sh @@ -36,6 +36,7 @@ declare -A -r LIBRARIES=( ["apigateway"]="@com_google_googleapis//google/cloud/apigateway/v1:apigateway_cc_grpc" ["apigeeconnect"]="@com_google_googleapis//google/cloud/apigeeconnect/v1:apigeeconnect_cc_grpc" ["apikeys"]="@com_google_googleapis//google/api/apikeys/v2:apikeys_cc_grpc" + ["apiregistry"]="@com_google_googleapis//google/cloud/apiregistry/v1:apiregistry_cc_grpc" ["appengine"]="$( printf ",%s" \ "@com_google_googleapis//google/appengine/v1:appengine_cc_grpc" \ diff --git a/generator/generator_config.textproto b/generator/generator_config.textproto index bbbbfb69b3161..443cc0839d75d 100644 --- a/generator/generator_config.textproto +++ b/generator/generator_config.textproto @@ -295,6 +295,14 @@ service { retryable_status_codes: ["kUnavailable"] } +# API Registry +service { + service_proto_path: "google/cloud/apiregistry/v1/service.proto" + product_path: "google/cloud/apiregistry/v1" + initial_copyright_year: "2026" + retryable_status_codes: ["kUnavailable"] +} + # App Engine Admin service { service_proto_path: "google/appengine/v1/appengine.proto" From d75e31790e069294b268209e5bd0004d2a359461 Mon Sep 17 00:00:00 2001 From: Scott Hart Date: Thu, 5 Feb 2026 13:28:53 -0500 Subject: [PATCH 2/6] Run generators and format their outputs --- README.md | 3 + ci/etc/expected_install_directories | 6 + .../googleapis/protodeps/apiregistry.deps | 6 + .../googleapis/protolists/apiregistry.list | 3 + google/cloud/apiregistry/BUILD.bazel | 31 ++ google/cloud/apiregistry/CMakeLists.txt | 36 ++ google/cloud/apiregistry/README.md | 59 +++ .../apiregistry/doc/environment-variables.dox | 49 ++ google/cloud/apiregistry/doc/main.dox | 48 ++ google/cloud/apiregistry/doc/options.dox | 10 + .../doc/override-authentication.dox | 35 ++ .../apiregistry/doc/override-endpoint.dox | 25 + .../doc/override-retry-policies.dox | 104 +++++ .../doc/override-universe-domain.dox | 24 + google/cloud/apiregistry/quickstart/.bazelrc | 30 ++ .../cloud/apiregistry/quickstart/BUILD.bazel | 25 + .../apiregistry/quickstart/CMakeLists.txt | 32 ++ google/cloud/apiregistry/quickstart/Makefile | 35 ++ google/cloud/apiregistry/quickstart/README.md | 135 ++++++ .../apiregistry/quickstart/WORKSPACE.bazel | 53 +++ .../apiregistry/quickstart/quickstart.cc | 42 ++ .../cloud/apiregistry/v1/.repo-metadata.json | 14 + .../v1/cloud_api_registry_client.cc | 115 +++++ .../v1/cloud_api_registry_client.h | 434 ++++++++++++++++++ .../v1/cloud_api_registry_connection.cc | 103 +++++ .../v1/cloud_api_registry_connection.h | 235 ++++++++++ ..._registry_connection_idempotency_policy.cc | 75 +++ ...i_registry_connection_idempotency_policy.h | 68 +++ .../v1/cloud_api_registry_options.h | 76 +++ .../cloud_api_registry_auth_decorator.cc | 90 ++++ .../cloud_api_registry_auth_decorator.h | 79 ++++ .../cloud_api_registry_connection_impl.cc | 212 +++++++++ .../cloud_api_registry_connection_impl.h | 83 ++++ .../cloud_api_registry_logging_decorator.cc | 116 +++++ .../cloud_api_registry_logging_decorator.h | 79 ++++ .../cloud_api_registry_metadata_decorator.cc | 117 +++++ .../cloud_api_registry_metadata_decorator.h | 85 ++++ .../cloud_api_registry_option_defaults.cc | 69 +++ .../cloud_api_registry_option_defaults.h | 37 ++ .../cloud_api_registry_retry_traits.h | 43 ++ .../v1/internal/cloud_api_registry_sources.cc | 32 ++ .../v1/internal/cloud_api_registry_stub.cc | 108 +++++ .../v1/internal/cloud_api_registry_stub.h | 119 +++++ .../cloud_api_registry_stub_factory.cc | 75 +++ .../cloud_api_registry_stub_factory.h | 42 ++ .../cloud_api_registry_tracing_connection.cc | 113 +++++ .../cloud_api_registry_tracing_connection.h | 84 ++++ .../cloud_api_registry_tracing_stub.cc | 121 +++++ .../cloud_api_registry_tracing_stub.h | 92 ++++ .../mock_cloud_api_registry_connection.h | 84 ++++ .../cloud_api_registry_client_samples.cc | 186 ++++++++ 51 files changed, 3977 insertions(+) create mode 100644 external/googleapis/protodeps/apiregistry.deps create mode 100644 external/googleapis/protolists/apiregistry.list create mode 100644 google/cloud/apiregistry/BUILD.bazel create mode 100644 google/cloud/apiregistry/CMakeLists.txt create mode 100644 google/cloud/apiregistry/README.md create mode 100644 google/cloud/apiregistry/doc/environment-variables.dox create mode 100644 google/cloud/apiregistry/doc/main.dox create mode 100644 google/cloud/apiregistry/doc/options.dox create mode 100644 google/cloud/apiregistry/doc/override-authentication.dox create mode 100644 google/cloud/apiregistry/doc/override-endpoint.dox create mode 100644 google/cloud/apiregistry/doc/override-retry-policies.dox create mode 100644 google/cloud/apiregistry/doc/override-universe-domain.dox create mode 100644 google/cloud/apiregistry/quickstart/.bazelrc create mode 100644 google/cloud/apiregistry/quickstart/BUILD.bazel create mode 100644 google/cloud/apiregistry/quickstart/CMakeLists.txt create mode 100644 google/cloud/apiregistry/quickstart/Makefile create mode 100644 google/cloud/apiregistry/quickstart/README.md create mode 100644 google/cloud/apiregistry/quickstart/WORKSPACE.bazel create mode 100644 google/cloud/apiregistry/quickstart/quickstart.cc create mode 100644 google/cloud/apiregistry/v1/.repo-metadata.json create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_client.cc create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_client.h create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_connection.cc create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_connection.h create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.cc create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h create mode 100644 google/cloud/apiregistry/v1/cloud_api_registry_options.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_sources.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.cc create mode 100644 google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h create mode 100644 google/cloud/apiregistry/v1/mocks/mock_cloud_api_registry_connection.h create mode 100644 google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc diff --git a/README.md b/README.md index 9914634f5fcb0..b59fe6a05f59f 100644 --- a/README.md +++ b/README.md @@ -119,6 +119,9 @@ See each library's `README.md` file for more information about: - [API Keys API](google/cloud/apikeys/README.md) [[quickstart]](google/cloud/apikeys/quickstart/README.md) [[reference]](https://cloud.google.com/cpp/docs/reference/apikeys/latest) +- [Cloud API Registry API](google/cloud/apiregistry/README.md) + [[quickstart]](google/cloud/apiregistry/quickstart/README.md) + [[reference]](https://cloud.google.com/cpp/docs/reference/apiregistry/latest) - [App Engine Admin API](google/cloud/appengine/README.md) [[quickstart]](google/cloud/appengine/quickstart/README.md) [[reference]](https://cloud.google.com/cpp/docs/reference/appengine/latest) diff --git a/ci/etc/expected_install_directories b/ci/etc/expected_install_directories index 7fa97fa28ce97..ecbad271aff7e 100644 --- a/ci/etc/expected_install_directories +++ b/ci/etc/expected_install_directories @@ -57,6 +57,10 @@ ./include/google/cloud/apikeys/v2 ./include/google/cloud/apikeys/v2/internal ./include/google/cloud/apikeys/v2/mocks +./include/google/cloud/apiregistry +./include/google/cloud/apiregistry/v1 +./include/google/cloud/apiregistry/v1/internal +./include/google/cloud/apiregistry/v1/mocks ./include/google/cloud/appengine ./include/google/cloud/appengine/mocks ./include/google/cloud/appengine/v1 @@ -1359,6 +1363,8 @@ ./lib64/cmake/google_cloud_cpp_apigeeconnect_mocks ./lib64/cmake/google_cloud_cpp_apikeys ./lib64/cmake/google_cloud_cpp_apikeys_mocks +./lib64/cmake/google_cloud_cpp_apiregistry +./lib64/cmake/google_cloud_cpp_apiregistry_mocks ./lib64/cmake/google_cloud_cpp_appengine ./lib64/cmake/google_cloud_cpp_appengine_mocks ./lib64/cmake/google_cloud_cpp_apphub diff --git a/external/googleapis/protodeps/apiregistry.deps b/external/googleapis/protodeps/apiregistry.deps new file mode 100644 index 0000000000000..2e749051efbb4 --- /dev/null +++ b/external/googleapis/protodeps/apiregistry.deps @@ -0,0 +1,6 @@ +@com_google_googleapis//google/api:annotations_proto +@com_google_googleapis//google/api:client_proto +@com_google_googleapis//google/api:field_behavior_proto +@com_google_googleapis//google/api:http_proto +@com_google_googleapis//google/api:launch_stage_proto +@com_google_googleapis//google/api:resource_proto diff --git a/external/googleapis/protolists/apiregistry.list b/external/googleapis/protolists/apiregistry.list new file mode 100644 index 0000000000000..6470878934037 --- /dev/null +++ b/external/googleapis/protolists/apiregistry.list @@ -0,0 +1,3 @@ +@com_google_googleapis//google/cloud/apiregistry/v1:common.proto +@com_google_googleapis//google/cloud/apiregistry/v1:resources.proto +@com_google_googleapis//google/cloud/apiregistry/v1:service.proto diff --git a/google/cloud/apiregistry/BUILD.bazel b/google/cloud/apiregistry/BUILD.bazel new file mode 100644 index 0000000000000..b6758ea5301a9 --- /dev/null +++ b/google/cloud/apiregistry/BUILD.bazel @@ -0,0 +1,31 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +load("//bazel:gapic.bzl", "cc_gapic_library") + +package(default_visibility = ["//visibility:private"]) + +licenses(["notice"]) # Apache 2.0 + +service_dirs = ["v1/"] + +googleapis_deps = [ + "@com_google_googleapis//google/cloud/apiregistry/v1:apiregistry_cc_grpc", +] + +cc_gapic_library( + name = "apiregistry", + googleapis_deps = googleapis_deps, + service_dirs = service_dirs, +) diff --git a/google/cloud/apiregistry/CMakeLists.txt b/google/cloud/apiregistry/CMakeLists.txt new file mode 100644 index 0000000000000..4017cb58e42e2 --- /dev/null +++ b/google/cloud/apiregistry/CMakeLists.txt @@ -0,0 +1,36 @@ +# ~~~ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. +# ~~~ + +include(GoogleCloudCppLibrary) + +google_cloud_cpp_add_gapic_library(apiregistry "Cloud API Registry API" + SERVICE_DIRS "v1/") + +if (BUILD_TESTING AND GOOGLE_CLOUD_CPP_ENABLE_CXX_EXCEPTIONS) + add_executable(apiregistry_quickstart "quickstart/quickstart.cc") + target_link_libraries(apiregistry_quickstart + PRIVATE google-cloud-cpp::apiregistry) + google_cloud_cpp_add_common_options(apiregistry_quickstart) + add_test( + NAME apiregistry_quickstart + COMMAND + cmake -P "${PROJECT_SOURCE_DIR}/cmake/quickstart-runner.cmake" + $ GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_CPP_TEST_REGION # EDIT HERE + ) + set_tests_properties(apiregistry_quickstart + PROPERTIES LABELS "integration-test;quickstart") +endif () diff --git a/google/cloud/apiregistry/README.md b/google/cloud/apiregistry/README.md new file mode 100644 index 0000000000000..add28155536f3 --- /dev/null +++ b/google/cloud/apiregistry/README.md @@ -0,0 +1,59 @@ +# Cloud API Registry API C++ Client Library + +This directory contains an idiomatic C++ client library for the +[Cloud API Registry API][cloud-service-docs]. + +While this library is **GA**, please note that the Google Cloud C++ client +libraries do **not** follow [Semantic Versioning](https://semver.org/). + +## Quickstart + +The [quickstart/](quickstart/README.md) directory contains a minimal environment +to get started using this client library in a larger project. The following +"Hello World" program is used in this quickstart, and should give you a taste of +this library. + + + +```cc +#include "google/cloud/apiregistry/v1/ EDIT HERE _client.h" +#include "google/cloud/location.h" +#include + +int main(int argc, char* argv[]) try { + if (argc != 3) { + std::cerr << "Usage: " << argv[0] << " project-id location-id\n"; + return 1; + } + + auto const location = google::cloud::Location(argv[1], argv[2]); + + namespace apiregistry = ::google::cloud::apiregistry_v1; + auto client = apiregistry::ServiceClient( + apiregistry::MakeServiceConnection()); // EDIT HERE + + for (auto r : client.List /*EDIT HERE*/ (location.FullName())) { + if (!r) throw std::move(r).status(); + std::cout << r->DebugString() << "\n"; + } + + return 0; +} catch (google::cloud::Status const& status) { + std::cerr << "google::cloud::Status thrown: " << status << "\n"; + return 1; +} +``` + + + +## More Information + +- Official documentation about the [Cloud API Registry API][cloud-service-docs] + service +- [Reference doxygen documentation][doxygen-link] for each release of this + client library +- Detailed header comments in our [public `.h`][source-link] files + +[cloud-service-docs]: https://docs.cloud.google.com/api-registry/docs/overview +[doxygen-link]: https://cloud.google.com/cpp/docs/reference/apiregistry/latest/ +[source-link]: https://github.com/googleapis/google-cloud-cpp/tree/main/google/cloud/apiregistry diff --git a/google/cloud/apiregistry/doc/environment-variables.dox b/google/cloud/apiregistry/doc/environment-variables.dox new file mode 100644 index 0000000000000..b3b224e1a219e --- /dev/null +++ b/google/cloud/apiregistry/doc/environment-variables.dox @@ -0,0 +1,49 @@ +/*! +@page apiregistry-env Environment Variables + +A number of environment variables can be used to configure the behavior of +the library. There are also functions to configure this behavior in code. The +environment variables are convenient when troubleshooting problems. + +@section apiregistry-env-endpoint Endpoint Overrides + + + +- `GOOGLE_CLOUD_CPP_CLOUD_API_REGISTRY_ENDPOINT=...` overrides the + `EndpointOption` (which defaults to "cloudapiregistry.googleapis.com") + used by `MakeCloudApiRegistryConnection()`. + + + +@see google::cloud::EndpointOption + +@section apiregistry-env-logging Logging + +`GOOGLE_CLOUD_CPP_ENABLE_TRACING=rpc`: turns on tracing for most gRPC +calls. The library injects an additional Stub decorator that prints each gRPC +request and response. Unless you have configured your own logging backend, +you should also set `GOOGLE_CLOUD_CPP_ENABLE_CLOG` to produce any output on +the program's console. + +@see google::cloud::LoggingComponentsOption + +`GOOGLE_CLOUD_CPP_TRACING_OPTIONS=...`: modifies the behavior of gRPC tracing, +including whether messages will be output on multiple lines, or whether +string/bytes fields will be truncated. + +@see google::cloud::GrpcTracingOptionsOption + +`GOOGLE_CLOUD_CPP_ENABLE_CLOG=yes`: turns on logging in the library, basically +the library always "logs" but the logging infrastructure has no backend to +actually print anything until the application sets a backend or they set this +environment variable. + +@see google::cloud::LogBackend +@see google::cloud::LogSink + +@section apiregistry-env-project Setting the Default Project + +`GOOGLE_CLOUD_PROJECT=...`: is used in examples and integration tests to +configure the GCP project. This has no effect in the library. + +*/ diff --git a/google/cloud/apiregistry/doc/main.dox b/google/cloud/apiregistry/doc/main.dox new file mode 100644 index 0000000000000..1c7d3c239717f --- /dev/null +++ b/google/cloud/apiregistry/doc/main.dox @@ -0,0 +1,48 @@ +/*! + +@mainpage Cloud API Registry API C++ Client Library + +An idiomatic C++ client library for the [Cloud API Registry API][cloud-service-docs]. + + + +While this library is **GA**, please note that the Google Cloud C++ client libraries do **not** follow +[Semantic Versioning](https://semver.org/). + +@tableofcontents{HTML:2} + +## Quickstart + +The following shows the code that you'll run in the +`google/cloud/apiregistry/quickstart/` directory, +which should give you a taste of the Cloud API Registry API C++ client library API. + +@snippet quickstart.cc all + +## Main classes + + +The main class in this library is +[`apiregistry_v1::CloudApiRegistryClient`](@ref google::cloud::apiregistry_v1::CloudApiRegistryClient). All RPCs are exposed +as member functions of this class. Other classes provide helpers, configuration +parameters, and infrastructure to mock +[`apiregistry_v1::CloudApiRegistryClient`](@ref google::cloud::apiregistry_v1::CloudApiRegistryClient) when testing your +application. + + +## More Information + +- @ref common-error-handling - describes how the library reports errors. +- @ref apiregistry-override-endpoint - describes how to override the default + endpoint. +- @ref apiregistry-override-authentication - describes how to change the + authentication credentials used by the library. +- @ref apiregistry-override-retry - describes how to change the default retry + policies. +- @ref apiregistry-env - describes environment variables that can configure the + behavior of the library. +- @ref apiregistry-override-universe-domain - describes how to override the default universe domain. + +[cloud-service-docs]: https://docs.cloud.google.com/api-registry/docs/overview + +*/ diff --git a/google/cloud/apiregistry/doc/options.dox b/google/cloud/apiregistry/doc/options.dox new file mode 100644 index 0000000000000..a242d0960cd33 --- /dev/null +++ b/google/cloud/apiregistry/doc/options.dox @@ -0,0 +1,10 @@ +/*! +@defgroup google-cloud-apiregistry-options Cloud API Registry API Configuration Options + +This library uses the same mechanism (`google::cloud::Options`) and the common +[options](@ref options) as all other C++ client libraries for its configuration. +Some `*Option` classes, which are only used in this library, are documented in +this page. + +@see @ref options - for an overview of client library configuration. +*/ diff --git a/google/cloud/apiregistry/doc/override-authentication.dox b/google/cloud/apiregistry/doc/override-authentication.dox new file mode 100644 index 0000000000000..32ba77596698b --- /dev/null +++ b/google/cloud/apiregistry/doc/override-authentication.dox @@ -0,0 +1,35 @@ +/*! +@page apiregistry-override-authentication How to Override the Authentication Credentials + +Unless otherwise configured, the client libraries use +[Application Default Credentials] to authenticate with Google Cloud Services. +While this works for most applications, in some cases you may need to override +this default. You can do so by providing the +[UnifiedCredentialsOption](@ref google::cloud::UnifiedCredentialsOption) +The following example shows how to explicitly load a service account key file: + + +@snippet cloud_api_registry_client_samples.cc with-service-account + + + +Keep in mind that we chose this as an example because it is relatively easy to +understand. Consult the [Best practices for managing service account keys] +guide for more details. + +@see @ref guac - for more information on the factory functions to create +`google::cloud::Credentials` objects. + +[Best practices for managing service account keys]: https://cloud.google.com/iam/docs/best-practices-for-managing-service-account-keys +[Application Default Credentials]: https://cloud.google.com/docs/authentication#adc + +*/ + +// + +/*! @page apiregistry_v1::CloudApiRegistryClient-service-account-snippet Override apiregistry_v1::CloudApiRegistryClient Authentication Defaults + +@snippet google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc with-service-account + +*/ +// diff --git a/google/cloud/apiregistry/doc/override-endpoint.dox b/google/cloud/apiregistry/doc/override-endpoint.dox new file mode 100644 index 0000000000000..8293e15f204c2 --- /dev/null +++ b/google/cloud/apiregistry/doc/override-endpoint.dox @@ -0,0 +1,25 @@ +/*! +@page apiregistry-override-endpoint How to Override the Default Endpoint + +In some cases, you may need to override the default endpoint used by the client +library. Use the +[EndpointOption](@ref google::cloud::EndpointOption) when initializing the +client library to change this default. + + +For example, this will override the default endpoint for `apiregistry_v1::CloudApiRegistryClient`: + +@snippet cloud_api_registry_client_samples.cc set-client-endpoint + + + +*/ + +// + +/*! @page apiregistry_v1::CloudApiRegistryClient-endpoint-snippet Override apiregistry_v1::CloudApiRegistryClient Endpoint Configuration + +@snippet google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc set-client-endpoint + +*/ +// diff --git a/google/cloud/apiregistry/doc/override-retry-policies.dox b/google/cloud/apiregistry/doc/override-retry-policies.dox new file mode 100644 index 0000000000000..1d8bc86ab6a6a --- /dev/null +++ b/google/cloud/apiregistry/doc/override-retry-policies.dox @@ -0,0 +1,104 @@ +/*! +@page apiregistry-override-retry Override Retry, Backoff, and Idempotency Policies + +When it is safe to do so, the library automatically retries requests that fail +due to a transient error. The library then uses [exponential backoff] to backoff +before trying again. Which operations are considered safe to retry, which +errors are treated as transient failures, the details of the exponential backoff +algorithm, and for how long the library retries are all configurable via +policies. + +This document provides examples showing how to override the default policies. + +The policies can be set when the `*Connection` object is created. The library +provides default policies for any policy that is not set. The application can +also override some (or all) policies when the `*Client` object is created. This +can be useful if multiple `*Client` objects share the same `*Connection` object, +but you want different retry behavior in some of the clients. Finally, the +application can override some retry policies when calling a specific member +function. + +The library uses three different options to control the retry loop. The options +have per-client names. + +@section apiregistry-override-retry-retry-policy Configuring the transient errors and retry duration + +The `*RetryPolicyOption` controls: + +- Which errors are to be treated as transient errors. +- How long the library will keep retrying transient errors. + +You can provide your own class for this option. The library also provides two +built-in policies: + +- `*LimitedErrorCountRetryPolicy`: stops retrying after a specified number + of transient errors. +- `*LimitedTimeRetryPolicy`: stops retrying after a specified time. + +Note that a library may have more than one version of these classes. Their name +match the `*Client` and `*Connection` object they are intended to be used +with. Some `*Client` objects treat different error codes as transient errors. +In most cases, only [kUnavailable](@ref google::cloud::StatusCode) is treated +as a transient error. + +@section apiregistry-override-retry-backoff-policy Controlling the backoff algorithm + +The `*BackoffPolicyOption` controls how long the client library will wait +before retrying a request that failed with a transient error. You can provide +your own class for this option. + +The only built-in backoff policy is +[`ExponentialBackoffPolicy`](@ref google::cloud::ExponentialBackoffPolicy). +This class implements a truncated exponential backoff algorithm, with jitter. +In summary, it doubles the current backoff time after each failure. The actual +backoff time for an RPC is chosen at random, but never exceeds the current +backoff. The current backoff is doubled after each failure, but never exceeds +(or is "truncated") if it reaches a prescribed maximum. + +@section apiregistry-override-retry-idempotency-policy Controlling which operations are retryable + +The `*IdempotencyPolicyOption` controls which requests are retryable, as some +requests are never safe to retry. + +Only one built-in idempotency policy is provided by the library. The name +matches the name of the client it is intended for. For example, `FooBarClient` +will use `FooBarIdempotencyPolicy`. This policy is very conservative. + +@section apiregistry-override-retry-example Example + + +For example, this will override the retry policies for `apiregistry_v1::CloudApiRegistryClient`: + +@snippet cloud_api_registry_client_samples.cc set-retry-policy + +This assumes you have created a custom idempotency policy. Such as: + +@snippet cloud_api_registry_client_samples.cc custom-idempotency-policy + + + + +@section apiregistry-override-retry-more-information More Information + +@see google::cloud::Options +@see google::cloud::BackoffPolicy +@see google::cloud::ExponentialBackoffPolicy + +[exponential backoff]: https://en.wikipedia.org/wiki/Exponential_backoff + +*/ + +// + +/*! @page apiregistry_v1::CloudApiRegistryClient-retry-snippet Override apiregistry_v1::CloudApiRegistryClient Retry Policies + +This shows how to override the retry policies for apiregistry_v1::CloudApiRegistryClient: + +@snippet google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc set-retry-policy + +Assuming you have created a custom idempotency policy. Such as: + +@snippet google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc custom-idempotency-policy + +*/ +// diff --git a/google/cloud/apiregistry/doc/override-universe-domain.dox b/google/cloud/apiregistry/doc/override-universe-domain.dox new file mode 100644 index 0000000000000..7ef2ff2c8122e --- /dev/null +++ b/google/cloud/apiregistry/doc/override-universe-domain.dox @@ -0,0 +1,24 @@ +/*! +@page apiregistry-override-universe-domain How to Override the Default Universe Domain + +In some cases, you may need to override the default universe domain used by the +client library. Use `AddUniverseDomainOption` when initializing the client +library to change this default. + + +For example, this will override the default universe domain for `apiregistry_v1::CloudApiRegistryClient`: + +@snippet cloud_api_registry_client_samples.cc set-client-universe-domain + + + +*/ + +// + +/*! @page apiregistry_v1::CloudApiRegistryClient-universe-domain-snippet Override apiregistry_v1::CloudApiRegistryClient Universe Domain + +@snippet google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc set-client-universe-domain + +*/ +// diff --git a/google/cloud/apiregistry/quickstart/.bazelrc b/google/cloud/apiregistry/quickstart/.bazelrc new file mode 100644 index 0000000000000..c884db46c2b4d --- /dev/null +++ b/google/cloud/apiregistry/quickstart/.bazelrc @@ -0,0 +1,30 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +# Use host-OS-specific config lines from bazelrc files. +build --enable_platform_specific_config=true + +# The project requires C++ >= 14. By default Bazel adds `-std=c++0x` which +# disables C++14 features, even if the compilers defaults to C++ >= 14 +build:linux --cxxopt=-std=c++14 +build:macos --cxxopt=-std=c++14 +# Protobuf and gRPC require (or soon will require) C++14 to compile the "host" +# targets, such as protoc and the grpc plugin. +build:linux --host_cxxopt=-std=c++14 +build:macos --host_cxxopt=-std=c++14 + +# Do not create the convenience links. They are inconvenient when the build +# runs inside a docker image or if one builds a quickstart and then builds +# the project separately. +build --experimental_convenience_symlinks=ignore diff --git a/google/cloud/apiregistry/quickstart/BUILD.bazel b/google/cloud/apiregistry/quickstart/BUILD.bazel new file mode 100644 index 0000000000000..6adfc23fb2a1f --- /dev/null +++ b/google/cloud/apiregistry/quickstart/BUILD.bazel @@ -0,0 +1,25 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +licenses(["notice"]) # Apache 2.0 + +cc_binary( + name = "quickstart", + srcs = [ + "quickstart.cc", + ], + deps = [ + "@google_cloud_cpp//:apiregistry", + ], +) diff --git a/google/cloud/apiregistry/quickstart/CMakeLists.txt b/google/cloud/apiregistry/quickstart/CMakeLists.txt new file mode 100644 index 0000000000000..1d782abb87bee --- /dev/null +++ b/google/cloud/apiregistry/quickstart/CMakeLists.txt @@ -0,0 +1,32 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +# This file shows how to use the Cloud API Registry API C++ client library from +# a larger CMake project. + +cmake_minimum_required(VERSION 3.10...3.24) +project(google-cloud-cpp-apiregistry-quickstart CXX) + +find_package(google_cloud_cpp_apiregistry REQUIRED) + +# MSVC requires some additional code to select the correct runtime library +if (VCPKG_TARGET_TRIPLET MATCHES "-static$") + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +else () + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") +endif () + +# Define your targets. +add_executable(quickstart quickstart.cc) +target_link_libraries(quickstart google-cloud-cpp::apiregistry) diff --git a/google/cloud/apiregistry/quickstart/Makefile b/google/cloud/apiregistry/quickstart/Makefile new file mode 100644 index 0000000000000..70dc009e8162a --- /dev/null +++ b/google/cloud/apiregistry/quickstart/Makefile @@ -0,0 +1,35 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +# This is a minimal Makefile to show how to use the Cloud API Registry API C++ client +# for developers who use make(1) as their build system. + +# The CXX, CXXFLAGS and CXXLD variables are hard-coded. These values work for +# our tests, but applications would typically make them configurable parameters. +CXX=g++ +CXXFLAGS= +CXXLD=$(CXX) +BIN=. + +all: $(BIN)/quickstart + +# Configuration variables to compile and link against the Cloud API Registry API C++ +# client library. +CLIENT_MODULE := google_cloud_cpp_apiregistry +CLIENT_CXXFLAGS := $(shell pkg-config $(CLIENT_MODULE) --cflags) +CLIENT_CXXLDFLAGS := $(shell pkg-config $(CLIENT_MODULE) --libs-only-L) +CLIENT_LIBS := $(shell pkg-config $(CLIENT_MODULE) --libs-only-l) + +$(BIN)/quickstart: quickstart.cc + $(CXXLD) $(CXXFLAGS) $(CLIENT_CXXFLAGS) $(CLIENT_CXXLDFLAGS) -o $@ $^ $(CLIENT_LIBS) diff --git a/google/cloud/apiregistry/quickstart/README.md b/google/cloud/apiregistry/quickstart/README.md new file mode 100644 index 0000000000000..1a80dc7d033a0 --- /dev/null +++ b/google/cloud/apiregistry/quickstart/README.md @@ -0,0 +1,135 @@ +# HOWTO: using the Cloud API Registry API C++ client in your project + +This directory contains small examples showing how to use the Cloud API Registry +API C++ client library in your own project. These instructions assume that you +have some experience as a C++ developer and that you have a working C++ +toolchain (compiler, linker, etc.) installed on your platform. + +- Packaging maintainers or developers who prefer to install the library in a + fixed directory (such as `/usr/local` or `/opt`) should consult the + [packaging guide](/doc/packaging.md). +- Developers who prefer using a package manager such as + [vcpkg](https://vcpkg.io), or [Conda](https://conda.io), should follow the + instructions for their package manager. +- Developers wanting to use the libraries as part of a larger CMake or Bazel + project should consult the current document. Note that there are similar + documents for each library in their corresponding directories. +- Developers wanting to compile the library just to run some examples or tests + should consult the + [building and installing](/README.md#building-and-installing) section of the + top-level README file. +- Contributors and developers to `google-cloud-cpp` should consult the guide to + [set up a development workstation][howto-setup-dev-workstation]. + +## Before you begin + +To run the quickstart examples you will need a working Google Cloud Platform +(GCP) project. + +## Configuring authentication for the C++ Client Library + +Like most Google Cloud Platform (GCP) services, Cloud API Registry API requires +that your application authenticates with the service before accessing any data. +If you are not familiar with GCP authentication please take this opportunity to +review the [Authentication methods at Google][authentication-quickstart]. + +## Using with Bazel + +> :warning: If you are using Windows or macOS there are additional instructions +> at the end of this document. + +1. Install Bazel using [the instructions][bazel-install] from the `bazel.build` + website. + +1. Compile this example using Bazel: + + ```bash + cd $HOME/google-cloud-cpp/google/cloud/apiregistry/quickstart + bazel build ... + ``` + + Note that Bazel automatically downloads and compiles all dependencies of the + project. As it is often the case with C++ libraries, compiling these + dependencies may take several minutes. + +1. Run the example, changing the placeholder(s) to appropriate values: + + ```bash + bazel run :quickstart -- [...] + ``` + +## Using with CMake + +> :warning: If you are using Windows or macOS there are additional instructions +> at the end of this document. + +1. Install CMake. The package managers for most Linux distributions include a + package for CMake. Likewise, you can install CMake on Windows using a package + manager such as [chocolatey][choco-cmake-link], and on macOS using + [homebrew][homebrew-cmake-link]. You can also obtain the software directly + from the [cmake.org](https://cmake.org/download/). + +1. Install the dependencies with your favorite tools. As an example, if you use + [vcpkg](https://github.com/Microsoft/vcpkg.git): + + ```bash + cd $HOME/vcpkg + ./vcpkg install google-cloud-cpp[core,apiregistry] + ``` + + Note that, as it is often the case with C++ libraries, compiling these + dependencies may take several minutes. + +1. Configure CMake, if necessary, configure the directory where you installed + the dependencies: + + ```bash + cd $HOME/google-cloud-cpp/google/cloud/apiregistry/quickstart + cmake -S . -B .build -DCMAKE_TOOLCHAIN_FILE=$HOME/vcpkg/scripts/buildsystems/vcpkg.cmake + cmake --build .build + ``` + +1. Run the example, changing the placeholder(s) to appropriate values: + + ```bash + .build/quickstart [...] + ``` + +## Platform Specific Notes + +### macOS + +gRPC [requires][grpc-roots-pem-bug] an environment variable to configure the +trust store for SSL certificates, you can download and configure this using: + +```bash +curl -Lo roots.pem https://pki.google.com/roots.pem +export GRPC_DEFAULT_SSL_ROOTS_FILE_PATH="$PWD/roots.pem" +``` + +### Windows + +Bazel tends to create very long file names and paths. You may need to use a +short directory to store the build output, such as `c:\b`, and instruct Bazel to +use it via: + +```shell +bazel --output_user_root=c:\b build ... +``` + +gRPC [requires][grpc-roots-pem-bug] an environment variable to configure the +trust store for SSL certificates, you can download and configure this using: + +```console +@powershell -NoProfile -ExecutionPolicy unrestricted -Command ^ + (new-object System.Net.WebClient).Downloadfile( ^ + 'https://pki.google.com/roots.pem', 'roots.pem') +set GRPC_DEFAULT_SSL_ROOTS_FILE_PATH=%cd%\roots.pem +``` + +[authentication-quickstart]: https://cloud.google.com/docs/authentication/client-libraries "Authenticate for using client libraries" +[bazel-install]: https://docs.bazel.build/versions/main/install.html +[choco-cmake-link]: https://chocolatey.org/packages/cmake +[grpc-roots-pem-bug]: https://github.com/grpc/grpc/issues/16571 +[homebrew-cmake-link]: https://formulae.brew.sh/formula/cmake +[howto-setup-dev-workstation]: /doc/contributor/howto-guide-setup-development-workstation.md diff --git a/google/cloud/apiregistry/quickstart/WORKSPACE.bazel b/google/cloud/apiregistry/quickstart/WORKSPACE.bazel new file mode 100644 index 0000000000000..0641bd5bc783e --- /dev/null +++ b/google/cloud/apiregistry/quickstart/WORKSPACE.bazel @@ -0,0 +1,53 @@ +# Copyright 2026 Google LLC +# +# 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 +# +# https://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. + +# A minimal WORKSPACE file showing how to use the Cloud API Registry API +# C++ client library in Bazel-based projects. +workspace(name = "qs") + +# Add the necessary Starlark functions to fetch google-cloud-cpp. +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +# Fetch the Google Cloud C++ libraries. +# NOTE: Update this version and SHA256 as needed. +http_archive( + name = "google_cloud_cpp", + sha256 = "699955112a4c57ae9111fbadeff1698674a1762acd77daf36360e6dfc227dc93", + strip_prefix = "google-cloud-cpp-2.42.0", + url = "https://github.com/googleapis/google-cloud-cpp/archive/v2.42.0.tar.gz", +) + +load("@google_cloud_cpp//bazel:workspace0.bzl", "gl_cpp_workspace0") + +gl_cpp_workspace0() + +load("@google_cloud_cpp//bazel:workspace1.bzl", "gl_cpp_workspace1") + +gl_cpp_workspace1() + +load("@google_cloud_cpp//bazel:workspace2.bzl", "gl_cpp_workspace2") + +gl_cpp_workspace2() + +load("@google_cloud_cpp//bazel:workspace3.bzl", "gl_cpp_workspace3") + +gl_cpp_workspace3() + +load("@google_cloud_cpp//bazel:workspace4.bzl", "gl_cpp_workspace4") + +gl_cpp_workspace4() + +load("@google_cloud_cpp//bazel:workspace5.bzl", "gl_cpp_workspace5") + +gl_cpp_workspace5() diff --git a/google/cloud/apiregistry/quickstart/quickstart.cc b/google/cloud/apiregistry/quickstart/quickstart.cc new file mode 100644 index 0000000000000..3d2276c43753f --- /dev/null +++ b/google/cloud/apiregistry/quickstart/quickstart.cc @@ -0,0 +1,42 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +//! [all] +#include "google/cloud/apiregistry/v1/ EDIT HERE _client.h" +#include "google/cloud/location.h" +#include + +int main(int argc, char* argv[]) try { + if (argc != 3) { + std::cerr << "Usage: " << argv[0] << " project-id location-id\n"; + return 1; + } + + auto const location = google::cloud::Location(argv[1], argv[2]); + + namespace apiregistry = ::google::cloud::apiregistry_v1; + auto client = apiregistry::ServiceClient( + apiregistry::MakeServiceConnection()); // EDIT HERE + + for (auto r : client.List /*EDIT HERE*/ (location.FullName())) { + if (!r) throw std::move(r).status(); + std::cout << r->DebugString() << "\n"; + } + + return 0; +} catch (google::cloud::Status const& status) { + std::cerr << "google::cloud::Status thrown: " << status << "\n"; + return 1; +} +//! [all] diff --git a/google/cloud/apiregistry/v1/.repo-metadata.json b/google/cloud/apiregistry/v1/.repo-metadata.json new file mode 100644 index 0000000000000..b5375587f57a4 --- /dev/null +++ b/google/cloud/apiregistry/v1/.repo-metadata.json @@ -0,0 +1,14 @@ +{ + "api_id": "cloudapiregistry.googleapis.com", + "api_shortname": "cloudapiregistry", + "client_documentation": "https://cloud.google.com/cpp/docs/reference/apiregistry/latest", + "distribution_name": "google-cloud-cpp", + "issue_tracker": "https://issuetracker.google.com/issues?q=componentid:1979613%20status=open", + "language": "cpp", + "library_type": "GAPIC_AUTO", + "name_pretty": "Cloud API Registry API", + "product_documentation": "https://docs.cloud.google.com/api-registry/docs/overview", + "release_level": "stable", + "repo": "googleapis/google-cloud-cpp", + "requires_billing": true +} diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_client.cc b/google/cloud/apiregistry/v1/cloud_api_registry_client.cc new file mode 100644 index 0000000000000..76ae467160e3b --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_client.cc @@ -0,0 +1,115 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/cloud_api_registry_client.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryClient::CloudApiRegistryClient( + std::shared_ptr connection, Options opts) + : connection_(std::move(connection)), + options_( + internal::MergeOptions(std::move(opts), connection_->options())) {} +CloudApiRegistryClient::~CloudApiRegistryClient() = default; + +StatusOr +CloudApiRegistryClient::GetMcpServer(std::string const& name, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + google::cloud::apiregistry::v1::GetMcpServerRequest request; + request.set_name(name); + return connection_->GetMcpServer(request); +} + +StatusOr +CloudApiRegistryClient::GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request, + Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->GetMcpServer(request); +} + +StreamRange +CloudApiRegistryClient::ListMcpServers(std::string const& parent, + Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + google::cloud::apiregistry::v1::ListMcpServersRequest request; + request.set_parent(parent); + return connection_->ListMcpServers(request); +} + +StreamRange +CloudApiRegistryClient::ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request, + Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->ListMcpServers(std::move(request)); +} + +StatusOr +CloudApiRegistryClient::GetMcpTool(std::string const& name, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + google::cloud::apiregistry::v1::GetMcpToolRequest request; + request.set_name(name); + return connection_->GetMcpTool(request); +} + +StatusOr +CloudApiRegistryClient::GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request, + Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->GetMcpTool(request); +} + +StreamRange +CloudApiRegistryClient::ListMcpTools(std::string const& parent, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + google::cloud::apiregistry::v1::ListMcpToolsRequest request; + request.set_parent(parent); + return connection_->ListMcpTools(request); +} + +StreamRange +CloudApiRegistryClient::ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->ListMcpTools(std::move(request)); +} + +StreamRange +CloudApiRegistryClient::ListLocations( + google::cloud::location::ListLocationsRequest request, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->ListLocations(std::move(request)); +} + +StatusOr CloudApiRegistryClient::GetLocation( + google::cloud::location::GetLocationRequest const& request, Options opts) { + internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_)); + return connection_->GetLocation(request); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_client.h b/google/cloud/apiregistry/v1/cloud_api_registry_client.h new file mode 100644 index 0000000000000..9f9dd8f876e93 --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_client.h @@ -0,0 +1,434 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CLIENT_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CLIENT_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/future.h" +#include "google/cloud/options.h" +#include "google/cloud/polling_policy.h" +#include "google/cloud/status_or.h" +#include "google/cloud/version.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +/// +/// The Cloud API Registry service provides a central registry for managing API +/// Data. +/// +/// @par Equality +/// +/// Instances of this class created via copy-construction or copy-assignment +/// always compare equal. Instances created with equal +/// `std::shared_ptr<*Connection>` objects compare equal. Objects that compare +/// equal share the same underlying resources. +/// +/// @par Performance +/// +/// Creating a new instance of this class is a relatively expensive operation, +/// new objects establish new connections to the service. In contrast, +/// copy-construction, move-construction, and the corresponding assignment +/// operations are relatively efficient as the copies share all underlying +/// resources. +/// +/// @par Thread Safety +/// +/// Concurrent access to different instances of this class, even if they compare +/// equal, is guaranteed to work. Two or more threads operating on the same +/// instance of this class is not guaranteed to work. Since copy-construction +/// and move-construction is a relatively efficient operation, consider using +/// such a copy when using this class from multiple threads. +/// +class CloudApiRegistryClient { + public: + explicit CloudApiRegistryClient( + std::shared_ptr connection, + Options opts = {}); + ~CloudApiRegistryClient(); + + ///@{ + /// @name Copy and move support + CloudApiRegistryClient(CloudApiRegistryClient const&) = default; + CloudApiRegistryClient& operator=(CloudApiRegistryClient const&) = default; + CloudApiRegistryClient(CloudApiRegistryClient&&) = default; + CloudApiRegistryClient& operator=(CloudApiRegistryClient&&) = default; + ///@} + + ///@{ + /// @name Equality + friend bool operator==(CloudApiRegistryClient const& a, + CloudApiRegistryClient const& b) { + return a.connection_ == b.connection_; + } + friend bool operator!=(CloudApiRegistryClient const& a, + CloudApiRegistryClient const& b) { + return !(a == b); + } + ///@} + + // clang-format off + /// + /// Gets a single McpServer. + /// + /// @param name Required. Name of the resource + /// Format: projects/{project}/locations/{location}/mcpServers/{mcp_server} + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return the result of the RPC. The response message type + /// ([google.cloud.apiregistry.v1.McpServer]) + /// is mapped to a C++ class using the [Protobuf mapping rules]. + /// If the request fails, the [`StatusOr`] contains the error details. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.GetMcpServerRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L78} + /// [google.cloud.apiregistry.v1.McpServer]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L34} + /// + // clang-format on + StatusOr GetMcpServer( + std::string const& name, Options opts = {}); + + // clang-format off + /// + /// Gets a single McpServer. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.apiregistry.v1.GetMcpServerRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return the result of the RPC. The response message type + /// ([google.cloud.apiregistry.v1.McpServer]) + /// is mapped to a C++ class using the [Protobuf mapping rules]. + /// If the request fails, the [`StatusOr`] contains the error details. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.GetMcpServerRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L78} + /// [google.cloud.apiregistry.v1.McpServer]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L34} + /// + // clang-format on + StatusOr GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request, + Options opts = {}); + + // clang-format off + /// + /// Lists McpServers in a given Project. + /// + /// @param parent Required. Parent value for ListMcpServersRequest + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return a [StreamRange](@ref google::cloud::StreamRange) + /// to iterate of the results. See the documentation of this type for + /// details. In brief, this class has `begin()` and `end()` member + /// functions returning a iterator class meeting the + /// [input iterator requirements]. The value type for this iterator is a + /// [`StatusOr`] as the iteration may fail even after some values are + /// retrieved successfully, for example, if there is a network disconnect. + /// An empty set of results does not indicate an error, it indicates + /// that there are no resources meeting the request criteria. + /// On a successful iteration the `StatusOr` contains elements of type + /// [google.cloud.apiregistry.v1.McpServer], or rather, + /// the C++ class generated by Protobuf from that type. Please consult the + /// Protobuf documentation for details on the [Protobuf mapping rules]. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.ListMcpServersRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L90} + /// [google.cloud.apiregistry.v1.McpServer]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L34} + /// + // clang-format on + StreamRange ListMcpServers( + std::string const& parent, Options opts = {}); + + // clang-format off + /// + /// Lists McpServers in a given Project. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.apiregistry.v1.ListMcpServersRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return a [StreamRange](@ref google::cloud::StreamRange) + /// to iterate of the results. See the documentation of this type for + /// details. In brief, this class has `begin()` and `end()` member + /// functions returning a iterator class meeting the + /// [input iterator requirements]. The value type for this iterator is a + /// [`StatusOr`] as the iteration may fail even after some values are + /// retrieved successfully, for example, if there is a network disconnect. + /// An empty set of results does not indicate an error, it indicates + /// that there are no resources meeting the request criteria. + /// On a successful iteration the `StatusOr` contains elements of type + /// [google.cloud.apiregistry.v1.McpServer], or rather, + /// the C++ class generated by Protobuf from that type. Please consult the + /// Protobuf documentation for details on the [Protobuf mapping rules]. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.ListMcpServersRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L90} + /// [google.cloud.apiregistry.v1.McpServer]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L34} + /// + // clang-format on + StreamRange ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request, + Options opts = {}); + + // clang-format off + /// + /// Gets a single McpTool. + /// + /// @param name Required. Name of the resource + /// Format: + /// projects/{project}/locations/{location}/mcpServers/{mcp_server}/mcpTools/{mcp_tool} + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return the result of the RPC. The response message type + /// ([google.cloud.apiregistry.v1.McpTool]) + /// is mapped to a C++ class using the [Protobuf mapping rules]. + /// If the request fails, the [`StatusOr`] contains the error details. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.GetMcpToolRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L131} + /// [google.cloud.apiregistry.v1.McpTool]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L72} + /// + // clang-format on + StatusOr GetMcpTool( + std::string const& name, Options opts = {}); + + // clang-format off + /// + /// Gets a single McpTool. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.apiregistry.v1.GetMcpToolRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return the result of the RPC. The response message type + /// ([google.cloud.apiregistry.v1.McpTool]) + /// is mapped to a C++ class using the [Protobuf mapping rules]. + /// If the request fails, the [`StatusOr`] contains the error details. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.GetMcpToolRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L131} + /// [google.cloud.apiregistry.v1.McpTool]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L72} + /// + // clang-format on + StatusOr GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request, + Options opts = {}); + + // clang-format off + /// + /// Lists McpTools in a given McpServer. + /// + /// @param parent Required. Parent value for ListMcpToolsRequest + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return a [StreamRange](@ref google::cloud::StreamRange) + /// to iterate of the results. See the documentation of this type for + /// details. In brief, this class has `begin()` and `end()` member + /// functions returning a iterator class meeting the + /// [input iterator requirements]. The value type for this iterator is a + /// [`StatusOr`] as the iteration may fail even after some values are + /// retrieved successfully, for example, if there is a network disconnect. + /// An empty set of results does not indicate an error, it indicates + /// that there are no resources meeting the request criteria. + /// On a successful iteration the `StatusOr` contains elements of type + /// [google.cloud.apiregistry.v1.McpTool], or rather, + /// the C++ class generated by Protobuf from that type. Please consult the + /// Protobuf documentation for details on the [Protobuf mapping rules]. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.ListMcpToolsRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L144} + /// [google.cloud.apiregistry.v1.McpTool]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L72} + /// + // clang-format on + StreamRange ListMcpTools( + std::string const& parent, Options opts = {}); + + // clang-format off + /// + /// Lists McpTools in a given McpServer. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.apiregistry.v1.ListMcpToolsRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return a [StreamRange](@ref google::cloud::StreamRange) + /// to iterate of the results. See the documentation of this type for + /// details. In brief, this class has `begin()` and `end()` member + /// functions returning a iterator class meeting the + /// [input iterator requirements]. The value type for this iterator is a + /// [`StatusOr`] as the iteration may fail even after some values are + /// retrieved successfully, for example, if there is a network disconnect. + /// An empty set of results does not indicate an error, it indicates + /// that there are no resources meeting the request criteria. + /// On a successful iteration the `StatusOr` contains elements of type + /// [google.cloud.apiregistry.v1.McpTool], or rather, + /// the C++ class generated by Protobuf from that type. Please consult the + /// Protobuf documentation for details on the [Protobuf mapping rules]. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.apiregistry.v1.ListMcpToolsRequest]: @googleapis_reference_link{google/cloud/apiregistry/v1/service.proto#L144} + /// [google.cloud.apiregistry.v1.McpTool]: @googleapis_reference_link{google/cloud/apiregistry/v1/resources.proto#L72} + /// + // clang-format on + StreamRange ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request, + Options opts = {}); + + // clang-format off + /// + /// Lists information about the supported locations for this service. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.location.ListLocationsRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return a [StreamRange](@ref google::cloud::StreamRange) + /// to iterate of the results. See the documentation of this type for + /// details. In brief, this class has `begin()` and `end()` member + /// functions returning a iterator class meeting the + /// [input iterator requirements]. The value type for this iterator is a + /// [`StatusOr`] as the iteration may fail even after some values are + /// retrieved successfully, for example, if there is a network disconnect. + /// An empty set of results does not indicate an error, it indicates + /// that there are no resources meeting the request criteria. + /// On a successful iteration the `StatusOr` contains elements of type + /// [google.cloud.location.Location], or rather, + /// the C++ class generated by Protobuf from that type. Please consult the + /// Protobuf documentation for details on the [Protobuf mapping rules]. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.location.ListLocationsRequest]: @googleapis_reference_link{google/cloud/location/locations.proto#L58} + /// [google.cloud.location.Location]: @googleapis_reference_link{google/cloud/location/locations.proto#L88} + /// + // clang-format on + StreamRange ListLocations( + google::cloud::location::ListLocationsRequest request, Options opts = {}); + + // clang-format off + /// + /// Gets information about a location. + /// + /// @param request Unary RPCs, such as the one wrapped by this + /// function, receive a single `request` proto message which includes all + /// the inputs for the RPC. In this case, the proto message is a + /// [google.cloud.location.GetLocationRequest]. + /// Proto messages are converted to C++ classes by Protobuf, using the + /// [Protobuf mapping rules]. + /// @param opts Optional. Override the class-level options, such as retry and + /// backoff policies. + /// @return the result of the RPC. The response message type + /// ([google.cloud.location.Location]) + /// is mapped to a C++ class using the [Protobuf mapping rules]. + /// If the request fails, the [`StatusOr`] contains the error details. + /// + /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/ + /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator + /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string + /// [`future`]: @ref google::cloud::future + /// [`StatusOr`]: @ref google::cloud::StatusOr + /// [`Status`]: @ref google::cloud::Status + /// [google.cloud.location.GetLocationRequest]: @googleapis_reference_link{google/cloud/location/locations.proto#L82} + /// [google.cloud.location.Location]: @googleapis_reference_link{google/cloud/location/locations.proto#L88} + /// + // clang-format on + StatusOr GetLocation( + google::cloud::location::GetLocationRequest const& request, + Options opts = {}); + + private: + std::shared_ptr connection_; + Options options_; +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CLIENT_H diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_connection.cc b/google/cloud/apiregistry/v1/cloud_api_registry_connection.cc new file mode 100644 index 0000000000000..49ff19d595650 --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_connection.cc @@ -0,0 +1,103 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_options.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h" +#include "google/cloud/background_threads.h" +#include "google/cloud/common_options.h" +#include "google/cloud/credentials.h" +#include "google/cloud/grpc_options.h" +#include "google/cloud/internal/pagination_range.h" +#include "google/cloud/internal/unified_grpc_credentials.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryConnection::~CloudApiRegistryConnection() = default; + +StatusOr +CloudApiRegistryConnection::GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const&) { + return Status(StatusCode::kUnimplemented, "not implemented"); +} + +StreamRange +CloudApiRegistryConnection::ListMcpServers( + google::cloud::apiregistry::v1:: + ListMcpServersRequest) { // NOLINT(performance-unnecessary-value-param) + return google::cloud::internal::MakeUnimplementedPaginationRange< + StreamRange>(); +} + +StatusOr +CloudApiRegistryConnection::GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const&) { + return Status(StatusCode::kUnimplemented, "not implemented"); +} + +StreamRange +CloudApiRegistryConnection::ListMcpTools( + google::cloud::apiregistry::v1:: + ListMcpToolsRequest) { // NOLINT(performance-unnecessary-value-param) + return google::cloud::internal::MakeUnimplementedPaginationRange< + StreamRange>(); +} + +StreamRange +CloudApiRegistryConnection::ListLocations( + google::cloud::location:: + ListLocationsRequest) { // NOLINT(performance-unnecessary-value-param) + return google::cloud::internal::MakeUnimplementedPaginationRange< + StreamRange>(); +} + +StatusOr +CloudApiRegistryConnection::GetLocation( + google::cloud::location::GetLocationRequest const&) { + return Status(StatusCode::kUnimplemented, "not implemented"); +} + +std::shared_ptr MakeCloudApiRegistryConnection( + Options options) { + internal::CheckExpectedOptions(options, + __func__); + options = apiregistry_v1_internal::CloudApiRegistryDefaultOptions( + std::move(options)); + auto background = internal::MakeBackgroundThreadsFactory(options)(); + auto auth = internal::CreateAuthenticationStrategy(background->cq(), options); + auto stub = apiregistry_v1_internal::CreateDefaultCloudApiRegistryStub( + std::move(auth), options); + return apiregistry_v1_internal::MakeCloudApiRegistryTracingConnection( + std::make_shared( + std::move(background), std::move(stub), std::move(options))); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_connection.h b/google/cloud/apiregistry/v1/cloud_api_registry_connection.h new file mode 100644 index 0000000000000..d2fc7bb2668eb --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_connection.h @@ -0,0 +1,235 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h" +#include "google/cloud/backoff_policy.h" +#include "google/cloud/internal/retry_policy_impl.h" +#include "google/cloud/options.h" +#include "google/cloud/status_or.h" +#include "google/cloud/stream_range.h" +#include "google/cloud/version.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +/// The retry policy for `CloudApiRegistryConnection`. +class CloudApiRegistryRetryPolicy : public ::google::cloud::RetryPolicy { + public: + /// Creates a new instance of the policy, reset to the initial state. + virtual std::unique_ptr clone() const = 0; +}; + +/** + * A retry policy for `CloudApiRegistryConnection` based on counting errors. + * + * This policy stops retrying if: + * - An RPC returns a non-transient error. + * - More than a prescribed number of transient failures is detected. + * + * In this class the following status codes are treated as transient errors: + * - [`kUnavailable`](@ref google::cloud::StatusCode) + */ +class CloudApiRegistryLimitedErrorCountRetryPolicy + : public CloudApiRegistryRetryPolicy { + public: + /** + * Create an instance that tolerates up to @p maximum_failures transient + * errors. + * + * @note Disable the retry loop by providing an instance of this policy with + * @p maximum_failures == 0. + */ + explicit CloudApiRegistryLimitedErrorCountRetryPolicy(int maximum_failures) + : impl_(maximum_failures) {} + + CloudApiRegistryLimitedErrorCountRetryPolicy( + CloudApiRegistryLimitedErrorCountRetryPolicy&& rhs) noexcept + : CloudApiRegistryLimitedErrorCountRetryPolicy(rhs.maximum_failures()) {} + CloudApiRegistryLimitedErrorCountRetryPolicy( + CloudApiRegistryLimitedErrorCountRetryPolicy const& rhs) noexcept + : CloudApiRegistryLimitedErrorCountRetryPolicy(rhs.maximum_failures()) {} + + int maximum_failures() const { return impl_.maximum_failures(); } + + bool OnFailure(Status const& status) override { + return impl_.OnFailure(status); + } + bool IsExhausted() const override { return impl_.IsExhausted(); } + bool IsPermanentFailure(Status const& status) const override { + return impl_.IsPermanentFailure(status); + } + std::unique_ptr clone() const override { + return std::make_unique( + maximum_failures()); + } + + // This is provided only for backwards compatibility. + using BaseType = CloudApiRegistryRetryPolicy; + + private: + google::cloud::internal::LimitedErrorCountRetryPolicy< + apiregistry_v1_internal::CloudApiRegistryRetryTraits> + impl_; +}; + +/** + * A retry policy for `CloudApiRegistryConnection` based on elapsed time. + * + * This policy stops retrying if: + * - An RPC returns a non-transient error. + * - The elapsed time in the retry loop exceeds a prescribed duration. + * + * In this class the following status codes are treated as transient errors: + * - [`kUnavailable`](@ref google::cloud::StatusCode) + */ +class CloudApiRegistryLimitedTimeRetryPolicy + : public CloudApiRegistryRetryPolicy { + public: + /** + * Constructor given a `std::chrono::duration<>` object. + * + * @tparam DurationRep a placeholder to match the `Rep` tparam for @p + * duration's type. The semantics of this template parameter are + * documented in `std::chrono::duration<>`. In brief, the underlying + * arithmetic type used to store the number of ticks. For our purposes it + * is simply a formal parameter. + * @tparam DurationPeriod a placeholder to match the `Period` tparam for @p + * duration's type. The semantics of this template parameter are + * documented in `std::chrono::duration<>`. In brief, the length of the + * tick in seconds, expressed as a `std::ratio<>`. For our purposes it is + * simply a formal parameter. + * @param maximum_duration the maximum time allowed before the policy expires. + * While the application can express this time in any units they desire, + * the class truncates to milliseconds. + * + * @see https://en.cppreference.com/w/cpp/chrono/duration for more information + * about `std::chrono::duration`. + */ + template + explicit CloudApiRegistryLimitedTimeRetryPolicy( + std::chrono::duration maximum_duration) + : impl_(maximum_duration) {} + + CloudApiRegistryLimitedTimeRetryPolicy( + CloudApiRegistryLimitedTimeRetryPolicy&& rhs) noexcept + : CloudApiRegistryLimitedTimeRetryPolicy(rhs.maximum_duration()) {} + CloudApiRegistryLimitedTimeRetryPolicy( + CloudApiRegistryLimitedTimeRetryPolicy const& rhs) noexcept + : CloudApiRegistryLimitedTimeRetryPolicy(rhs.maximum_duration()) {} + + std::chrono::milliseconds maximum_duration() const { + return impl_.maximum_duration(); + } + + bool OnFailure(Status const& status) override { + return impl_.OnFailure(status); + } + bool IsExhausted() const override { return impl_.IsExhausted(); } + bool IsPermanentFailure(Status const& status) const override { + return impl_.IsPermanentFailure(status); + } + std::unique_ptr clone() const override { + return std::make_unique( + maximum_duration()); + } + + // This is provided only for backwards compatibility. + using BaseType = CloudApiRegistryRetryPolicy; + + private: + google::cloud::internal::LimitedTimeRetryPolicy< + apiregistry_v1_internal::CloudApiRegistryRetryTraits> + impl_; +}; + +/** + * The `CloudApiRegistryConnection` object for `CloudApiRegistryClient`. + * + * This interface defines virtual methods for each of the user-facing overload + * sets in `CloudApiRegistryClient`. This allows users to inject custom behavior + * (e.g., with a Google Mock object) when writing tests that use objects of type + * `CloudApiRegistryClient`. + * + * To create a concrete instance, see `MakeCloudApiRegistryConnection()`. + * + * For mocking, see `apiregistry_v1_mocks::MockCloudApiRegistryConnection`. + */ +class CloudApiRegistryConnection { + public: + virtual ~CloudApiRegistryConnection() = 0; + + virtual Options options() { return Options{}; } + + virtual StatusOr GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request); + + virtual StreamRange ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request); + + virtual StatusOr GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request); + + virtual StreamRange ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request); + + virtual StreamRange ListLocations( + google::cloud::location::ListLocationsRequest request); + + virtual StatusOr GetLocation( + google::cloud::location::GetLocationRequest const& request); +}; + +/** + * A factory function to construct an object of type + * `CloudApiRegistryConnection`. + * + * The returned connection object should not be used directly; instead it + * should be passed as an argument to the constructor of CloudApiRegistryClient. + * + * The optional @p options argument may be used to configure aspects of the + * returned `CloudApiRegistryConnection`. Expected options are any of the types + * in the following option lists: + * + * - `google::cloud::CommonOptionList` + * - `google::cloud::GrpcOptionList` + * - `google::cloud::UnifiedCredentialsOptionList` + * - `google::cloud::apiregistry_v1::CloudApiRegistryPolicyOptionList` + * + * @note Unexpected options will be ignored. To log unexpected options instead, + * set `GOOGLE_CLOUD_CPP_ENABLE_CLOG=yes` in the environment. + * + * @param options (optional) Configure the `CloudApiRegistryConnection` created + * by this function. + */ +std::shared_ptr MakeCloudApiRegistryConnection( + Options options = {}); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_H diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.cc b/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.cc new file mode 100644 index 0000000000000..31114421b116b --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.cc @@ -0,0 +1,75 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +using ::google::cloud::Idempotency; + +CloudApiRegistryConnectionIdempotencyPolicy:: + ~CloudApiRegistryConnectionIdempotencyPolicy() = default; + +std::unique_ptr +CloudApiRegistryConnectionIdempotencyPolicy::clone() const { + return std::make_unique(*this); +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const&) { + return Idempotency::kIdempotent; +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest) { // NOLINT + return Idempotency::kIdempotent; +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const&) { + return Idempotency::kIdempotent; +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest) { // NOLINT + return Idempotency::kIdempotent; +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::ListLocations( + google::cloud::location::ListLocationsRequest) { // NOLINT + return Idempotency::kIdempotent; +} + +Idempotency CloudApiRegistryConnectionIdempotencyPolicy::GetLocation( + google::cloud::location::GetLocationRequest const&) { + return Idempotency::kIdempotent; +} + +std::unique_ptr +MakeDefaultCloudApiRegistryConnectionIdempotencyPolicy() { + return std::make_unique(); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h b/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h new file mode 100644 index 0000000000000..4ef1549399271 --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h @@ -0,0 +1,68 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_IDEMPOTENCY_POLICY_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_IDEMPOTENCY_POLICY_H + +#include "google/cloud/idempotency.h" +#include "google/cloud/version.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryConnectionIdempotencyPolicy { + public: + virtual ~CloudApiRegistryConnectionIdempotencyPolicy(); + + /// Create a new copy of this object. + virtual std::unique_ptr clone() + const; + + virtual google::cloud::Idempotency GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request); + + virtual google::cloud::Idempotency ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request); + + virtual google::cloud::Idempotency GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request); + + virtual google::cloud::Idempotency ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request); + + virtual google::cloud::Idempotency ListLocations( + google::cloud::location::ListLocationsRequest request); + + virtual google::cloud::Idempotency GetLocation( + google::cloud::location::GetLocationRequest const& request); +}; + +std::unique_ptr +MakeDefaultCloudApiRegistryConnectionIdempotencyPolicy(); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_CONNECTION_IDEMPOTENCY_POLICY_H diff --git a/google/cloud/apiregistry/v1/cloud_api_registry_options.h b/google/cloud/apiregistry/v1/cloud_api_registry_options.h new file mode 100644 index 0000000000000..cb88ba1952574 --- /dev/null +++ b/google/cloud/apiregistry/v1/cloud_api_registry_options.h @@ -0,0 +1,76 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_OPTIONS_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_OPTIONS_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h" +#include "google/cloud/backoff_policy.h" +#include "google/cloud/options.h" +#include "google/cloud/version.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1 { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +/** + * Use with `google::cloud::Options` to configure the retry policy. + * + * @ingroup google-cloud-apiregistry-options + */ +struct CloudApiRegistryRetryPolicyOption { + using Type = std::shared_ptr; +}; + +/** + * Use with `google::cloud::Options` to configure the backoff policy. + * + * @ingroup google-cloud-apiregistry-options + */ +struct CloudApiRegistryBackoffPolicyOption { + using Type = std::shared_ptr; +}; + +/** + * Use with `google::cloud::Options` to configure which operations are retried. + * + * @ingroup google-cloud-apiregistry-options + */ +struct CloudApiRegistryConnectionIdempotencyPolicyOption { + using Type = std::shared_ptr; +}; + +/** + * The options applicable to CloudApiRegistry. + * + * @ingroup google-cloud-apiregistry-options + */ +using CloudApiRegistryPolicyOptionList = + OptionList; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1 +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_CLOUD_API_REGISTRY_OPTIONS_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.cc new file mode 100644 index 0000000000000..5389a7dd2db0c --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.cc @@ -0,0 +1,90 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryAuth::CloudApiRegistryAuth( + std::shared_ptr auth, + std::shared_ptr child) + : auth_(std::move(auth)), child_(std::move(child)) {} + +StatusOr +CloudApiRegistryAuth::GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->GetMcpServer(context, options, request); +} + +StatusOr +CloudApiRegistryAuth::ListMcpServers( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->ListMcpServers(context, options, request); +} + +StatusOr +CloudApiRegistryAuth::GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->GetMcpTool(context, options, request); +} + +StatusOr +CloudApiRegistryAuth::ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->ListMcpTools(context, options, request); +} + +StatusOr +CloudApiRegistryAuth::ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->ListLocations(context, options, request); +} + +StatusOr CloudApiRegistryAuth::GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + auto status = auth_->ConfigureContext(context); + if (!status.ok()) return status; + return child_->GetLocation(context, options, request); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h new file mode 100644 index 0000000000000..a9e56dd00dd1d --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h @@ -0,0 +1,79 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_AUTH_DECORATOR_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_AUTH_DECORATOR_H + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/internal/unified_grpc_credentials.h" +#include "google/cloud/version.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryAuth : public CloudApiRegistryStub { + public: + ~CloudApiRegistryAuth() override = default; + CloudApiRegistryAuth( + std::shared_ptr auth, + std::shared_ptr child); + + StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StatusOr + ListMcpServers(grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) override; + + StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StatusOr ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) + override; + + StatusOr ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) override; + + StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::shared_ptr auth_; + std::shared_ptr child_; +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_AUTH_DECORATOR_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.cc new file mode 100644 index 0000000000000..8326f59e0483a --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.cc @@ -0,0 +1,212 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h" +#include "google/cloud/background_threads.h" +#include "google/cloud/common_options.h" +#include "google/cloud/grpc_options.h" +#include "google/cloud/internal/pagination_range.h" +#include "google/cloud/internal/retry_loop.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN +namespace { + +std::unique_ptr retry_policy( + Options const& options) { + return options.get() + ->clone(); +} + +std::unique_ptr backoff_policy(Options const& options) { + return options.get() + ->clone(); +} + +std::unique_ptr +idempotency_policy(Options const& options) { + return options + .get() + ->clone(); +} + +} // namespace + +CloudApiRegistryConnectionImpl::CloudApiRegistryConnectionImpl( + std::unique_ptr background, + std::shared_ptr stub, + Options options) + : background_(std::move(background)), + stub_(std::move(stub)), + options_(internal::MergeOptions(std::move(options), + CloudApiRegistryConnection::options())) {} + +StatusOr +CloudApiRegistryConnectionImpl::GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + auto current = google::cloud::internal::SaveCurrentOptions(); + return google::cloud::internal::RetryLoop( + retry_policy(*current), backoff_policy(*current), + idempotency_policy(*current)->GetMcpServer(request), + [this]( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + return stub_->GetMcpServer(context, options, request); + }, + *current, request, __func__); +} + +StreamRange +CloudApiRegistryConnectionImpl::ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request) { + request.clear_page_token(); + auto current = google::cloud::internal::SaveCurrentOptions(); + auto idempotency = idempotency_policy(*current)->ListMcpServers(request); + char const* function_name = __func__; + return google::cloud::internal::MakePaginationRange< + StreamRange>( + current, std::move(request), + [idempotency, function_name, stub = stub_, + retry = std::shared_ptr( + retry_policy(*current)), + backoff = std::shared_ptr(backoff_policy(*current))]( + Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& r) { + return google::cloud::internal::RetryLoop( + retry->clone(), backoff->clone(), idempotency, + [stub](grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) { + return stub->ListMcpServers(context, options, request); + }, + options, r, function_name); + }, + [](google::cloud::apiregistry::v1::ListMcpServersResponse r) { + std::vector result( + r.mcp_servers().size()); + auto& messages = *r.mutable_mcp_servers(); + std::move(messages.begin(), messages.end(), result.begin()); + return result; + }); +} + +StatusOr +CloudApiRegistryConnectionImpl::GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + auto current = google::cloud::internal::SaveCurrentOptions(); + return google::cloud::internal::RetryLoop( + retry_policy(*current), backoff_policy(*current), + idempotency_policy(*current)->GetMcpTool(request), + [this](grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + return stub_->GetMcpTool(context, options, request); + }, + *current, request, __func__); +} + +StreamRange +CloudApiRegistryConnectionImpl::ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request) { + request.clear_page_token(); + auto current = google::cloud::internal::SaveCurrentOptions(); + auto idempotency = idempotency_policy(*current)->ListMcpTools(request); + char const* function_name = __func__; + return google::cloud::internal::MakePaginationRange< + StreamRange>( + current, std::move(request), + [idempotency, function_name, stub = stub_, + retry = std::shared_ptr( + retry_policy(*current)), + backoff = std::shared_ptr(backoff_policy(*current))]( + Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& r) { + return google::cloud::internal::RetryLoop( + retry->clone(), backoff->clone(), idempotency, + [stub](grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& + request) { + return stub->ListMcpTools(context, options, request); + }, + options, r, function_name); + }, + [](google::cloud::apiregistry::v1::ListMcpToolsResponse r) { + std::vector result( + r.mcp_tools().size()); + auto& messages = *r.mutable_mcp_tools(); + std::move(messages.begin(), messages.end(), result.begin()); + return result; + }); +} + +StreamRange +CloudApiRegistryConnectionImpl::ListLocations( + google::cloud::location::ListLocationsRequest request) { + request.clear_page_token(); + auto current = google::cloud::internal::SaveCurrentOptions(); + auto idempotency = idempotency_policy(*current)->ListLocations(request); + char const* function_name = __func__; + return google::cloud::internal::MakePaginationRange< + StreamRange>( + current, std::move(request), + [idempotency, function_name, stub = stub_, + retry = std::shared_ptr( + retry_policy(*current)), + backoff = std::shared_ptr(backoff_policy(*current))]( + Options const& options, + google::cloud::location::ListLocationsRequest const& r) { + return google::cloud::internal::RetryLoop( + retry->clone(), backoff->clone(), idempotency, + [stub]( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + return stub->ListLocations(context, options, request); + }, + options, r, function_name); + }, + [](google::cloud::location::ListLocationsResponse r) { + std::vector result( + r.locations().size()); + auto& messages = *r.mutable_locations(); + std::move(messages.begin(), messages.end(), result.begin()); + return result; + }); +} + +StatusOr +CloudApiRegistryConnectionImpl::GetLocation( + google::cloud::location::GetLocationRequest const& request) { + auto current = google::cloud::internal::SaveCurrentOptions(); + return google::cloud::internal::RetryLoop( + retry_policy(*current), backoff_policy(*current), + idempotency_policy(*current)->GetLocation(request), + [this](grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + return stub_->GetLocation(context, options, request); + }, + *current, request, __func__); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h new file mode 100644 index 0000000000000..d397916d22b09 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.h @@ -0,0 +1,83 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_CONNECTION_IMPL_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_CONNECTION_IMPL_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_options.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/background_threads.h" +#include "google/cloud/backoff_policy.h" +#include "google/cloud/options.h" +#include "google/cloud/status_or.h" +#include "google/cloud/stream_range.h" +#include "google/cloud/version.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryConnectionImpl + : public apiregistry_v1::CloudApiRegistryConnection { + public: + ~CloudApiRegistryConnectionImpl() override = default; + + CloudApiRegistryConnectionImpl( + std::unique_ptr background, + std::shared_ptr stub, + Options options); + + Options options() override { return options_; } + + StatusOr GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StreamRange ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request) override; + + StatusOr GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StreamRange ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request) override; + + StreamRange ListLocations( + google::cloud::location::ListLocationsRequest request) override; + + StatusOr GetLocation( + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::unique_ptr background_; + std::shared_ptr stub_; + Options options_; +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_CONNECTION_IMPL_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.cc new file mode 100644 index 0000000000000..2afb0b0652370 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.cc @@ -0,0 +1,116 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h" +#include "google/cloud/internal/log_wrapper.h" +#include "google/cloud/status_or.h" +#include +#include +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryLogging::CloudApiRegistryLogging( + std::shared_ptr child, TracingOptions tracing_options, + std::set const&) + : child_(std::move(child)), tracing_options_(std::move(tracing_options)) {} + +StatusOr +CloudApiRegistryLogging::GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + return google::cloud::internal::LogWrapper( + [this]( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + return child_->GetMcpServer(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +StatusOr +CloudApiRegistryLogging::ListMcpServers( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) { + return google::cloud::internal::LogWrapper( + [this](grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) { + return child_->ListMcpServers(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +StatusOr +CloudApiRegistryLogging::GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + return google::cloud::internal::LogWrapper( + [this](grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + return child_->GetMcpTool(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +StatusOr +CloudApiRegistryLogging::ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + return google::cloud::internal::LogWrapper( + [this]( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + return child_->ListMcpTools(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +StatusOr +CloudApiRegistryLogging::ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + return google::cloud::internal::LogWrapper( + [this](grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + return child_->ListLocations(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +StatusOr +CloudApiRegistryLogging::GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + return google::cloud::internal::LogWrapper( + [this](grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + return child_->GetLocation(context, options, request); + }, + context, options, request, __func__, tracing_options_); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h new file mode 100644 index 0000000000000..51b2ebc1b7566 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h @@ -0,0 +1,79 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_LOGGING_DECORATOR_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_LOGGING_DECORATOR_H + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/tracing_options.h" +#include "google/cloud/version.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryLogging : public CloudApiRegistryStub { + public: + ~CloudApiRegistryLogging() override = default; + CloudApiRegistryLogging(std::shared_ptr child, + TracingOptions tracing_options, + std::set const& components); + + StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StatusOr + ListMcpServers(grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) override; + + StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StatusOr ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) + override; + + StatusOr ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) override; + + StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::shared_ptr child_; + TracingOptions tracing_options_; +}; // CloudApiRegistryLogging + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_LOGGING_DECORATOR_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.cc new file mode 100644 index 0000000000000..fe369e8676ed8 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.cc @@ -0,0 +1,117 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h" +#include "google/cloud/grpc_options.h" +#include "google/cloud/internal/absl_str_cat_quiet.h" +#include "google/cloud/internal/api_client_header.h" +#include "google/cloud/internal/url_encode.h" +#include "google/cloud/status_or.h" +#include +#include +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryMetadata::CloudApiRegistryMetadata( + std::shared_ptr child, + std::multimap fixed_metadata, + std::string api_client_header) + : child_(std::move(child)), + fixed_metadata_(std::move(fixed_metadata)), + api_client_header_( + api_client_header.empty() + ? google::cloud::internal::GeneratedLibClientHeader() + : std::move(api_client_header)) {} + +StatusOr +CloudApiRegistryMetadata::GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + SetMetadata(context, options, + absl::StrCat("name=", internal::UrlEncode(request.name()))); + return child_->GetMcpServer(context, options, request); +} + +StatusOr +CloudApiRegistryMetadata::ListMcpServers( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) { + SetMetadata(context, options, + absl::StrCat("parent=", internal::UrlEncode(request.parent()))); + return child_->ListMcpServers(context, options, request); +} + +StatusOr +CloudApiRegistryMetadata::GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + SetMetadata(context, options, + absl::StrCat("name=", internal::UrlEncode(request.name()))); + return child_->GetMcpTool(context, options, request); +} + +StatusOr +CloudApiRegistryMetadata::ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + SetMetadata(context, options, + absl::StrCat("parent=", internal::UrlEncode(request.parent()))); + return child_->ListMcpTools(context, options, request); +} + +StatusOr +CloudApiRegistryMetadata::ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + SetMetadata(context, options, + absl::StrCat("name=", internal::UrlEncode(request.name()))); + return child_->ListLocations(context, options, request); +} + +StatusOr +CloudApiRegistryMetadata::GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + SetMetadata(context, options, + absl::StrCat("name=", internal::UrlEncode(request.name()))); + return child_->GetLocation(context, options, request); +} + +void CloudApiRegistryMetadata::SetMetadata(grpc::ClientContext& context, + Options const& options, + std::string const& request_params) { + context.AddMetadata("x-goog-request-params", request_params); + SetMetadata(context, options); +} + +void CloudApiRegistryMetadata::SetMetadata(grpc::ClientContext& context, + Options const& options) { + google::cloud::internal::SetMetadata(context, options, fixed_metadata_, + api_client_header_); +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h new file mode 100644 index 0000000000000..2a24a658c606c --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h @@ -0,0 +1,85 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_METADATA_DECORATOR_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_METADATA_DECORATOR_H + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/options.h" +#include "google/cloud/version.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryMetadata : public CloudApiRegistryStub { + public: + ~CloudApiRegistryMetadata() override = default; + CloudApiRegistryMetadata( + std::shared_ptr child, + std::multimap fixed_metadata, + std::string api_client_header = ""); + + StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StatusOr + ListMcpServers(grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) override; + + StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StatusOr ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) + override; + + StatusOr ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) override; + + StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) override; + + private: + void SetMetadata(grpc::ClientContext& context, Options const& options, + std::string const& request_params); + void SetMetadata(grpc::ClientContext& context, Options const& options); + + std::shared_ptr child_; + std::multimap fixed_metadata_; + std::string api_client_header_; +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_METADATA_DECORATOR_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.cc new file mode 100644 index 0000000000000..29e305704f20e --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.cc @@ -0,0 +1,69 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_options.h" +#include "google/cloud/internal/populate_common_options.h" +#include "google/cloud/internal/populate_grpc_options.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +namespace { +auto constexpr kBackoffScaling = 2.0; +} // namespace + +Options CloudApiRegistryDefaultOptions(Options options) { + options = internal::PopulateCommonOptions( + std::move(options), "GOOGLE_CLOUD_CPP_CLOUD_API_REGISTRY_ENDPOINT", "", + "GOOGLE_CLOUD_CPP_CLOUD_API_REGISTRY_AUTHORITY", + "cloudapiregistry.googleapis.com"); + options = internal::PopulateGrpcOptions(std::move(options)); + if (!options.has()) { + options.set( + apiregistry_v1::CloudApiRegistryLimitedTimeRetryPolicy( + std::chrono::minutes(30)) + .clone()); + } + if (!options.has()) { + options.set( + ExponentialBackoffPolicy( + std::chrono::seconds(0), std::chrono::seconds(1), + std::chrono::minutes(5), kBackoffScaling, kBackoffScaling) + .clone()); + } + if (!options.has()) { + options + .set( + apiregistry_v1:: + MakeDefaultCloudApiRegistryConnectionIdempotencyPolicy()); + } + + return options; +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h new file mode 100644 index 0000000000000..8344d762bfad4 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.h @@ -0,0 +1,37 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_OPTION_DEFAULTS_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_OPTION_DEFAULTS_H + +#include "google/cloud/options.h" +#include "google/cloud/version.h" + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +Options CloudApiRegistryDefaultOptions(Options options); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_OPTION_DEFAULTS_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h new file mode 100644 index 0000000000000..8f3bff3341143 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_retry_traits.h @@ -0,0 +1,43 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_RETRY_TRAITS_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_RETRY_TRAITS_H + +#include "google/cloud/status.h" +#include "google/cloud/version.h" + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +/// Define the gRPC status code semantics for retrying requests. +struct CloudApiRegistryRetryTraits { + static bool IsPermanentFailure(google::cloud::Status const& status) { + return status.code() != StatusCode::kOk && + status.code() != StatusCode::kUnavailable; + } +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_RETRY_TRAITS_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_sources.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_sources.cc new file mode 100644 index 0000000000000..c500d7170d39a --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_sources.cc @@ -0,0 +1,32 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +// NOLINTBEGIN(bugprone-suspicious-include) +#include "google/cloud/apiregistry/v1/cloud_api_registry_client.cc" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.cc" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_connection_impl.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_option_defaults.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.cc" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.cc" +// NOLINTEND(bugprone-suspicious-include) diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.cc new file mode 100644 index 0000000000000..818a19cf4d3b7 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.cc @@ -0,0 +1,108 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/grpc_error_delegate.h" +#include "google/cloud/status_or.h" +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +CloudApiRegistryStub::~CloudApiRegistryStub() = default; + +StatusOr +DefaultCloudApiRegistryStub::GetMcpServer( + grpc::ClientContext& context, Options const&, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + google::cloud::apiregistry::v1::McpServer response; + auto status = grpc_stub_->GetMcpServer(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +StatusOr +DefaultCloudApiRegistryStub::ListMcpServers( + grpc::ClientContext& context, Options const&, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) { + google::cloud::apiregistry::v1::ListMcpServersResponse response; + auto status = grpc_stub_->ListMcpServers(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +StatusOr +DefaultCloudApiRegistryStub::GetMcpTool( + grpc::ClientContext& context, Options const&, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + google::cloud::apiregistry::v1::McpTool response; + auto status = grpc_stub_->GetMcpTool(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +StatusOr +DefaultCloudApiRegistryStub::ListMcpTools( + grpc::ClientContext& context, Options const&, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + google::cloud::apiregistry::v1::ListMcpToolsResponse response; + auto status = grpc_stub_->ListMcpTools(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +StatusOr +DefaultCloudApiRegistryStub::ListLocations( + grpc::ClientContext& context, Options const&, + google::cloud::location::ListLocationsRequest const& request) { + google::cloud::location::ListLocationsResponse response; + auto status = locations_stub_->ListLocations(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +StatusOr +DefaultCloudApiRegistryStub::GetLocation( + grpc::ClientContext& context, Options const&, + google::cloud::location::GetLocationRequest const& request) { + google::cloud::location::Location response; + auto status = locations_stub_->GetLocation(&context, request, &response); + if (!status.ok()) { + return google::cloud::MakeStatusFromRpcError(status); + } + return response; +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h new file mode 100644 index 0000000000000..211e3a889634f --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h @@ -0,0 +1,119 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_H + +#include "google/cloud/options.h" +#include "google/cloud/status_or.h" +#include "google/cloud/version.h" +#include +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +class CloudApiRegistryStub { + public: + virtual ~CloudApiRegistryStub() = 0; + + virtual StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) = 0; + + virtual StatusOr + ListMcpServers( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) = 0; + + virtual StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) = 0; + + virtual StatusOr + ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) = 0; + + virtual StatusOr + ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) = 0; + + virtual StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) = 0; +}; + +class DefaultCloudApiRegistryStub : public CloudApiRegistryStub { + public: + explicit DefaultCloudApiRegistryStub( + std::unique_ptr< + google::cloud::apiregistry::v1::CloudApiRegistry::StubInterface> + grpc_stub, + std::unique_ptr + locations_stub) + : grpc_stub_(std::move(grpc_stub)), + locations_stub_(std::move(locations_stub)) {} + + StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StatusOr + ListMcpServers(grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) override; + + StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StatusOr ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) + override; + + StatusOr ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) override; + + StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::unique_ptr< + google::cloud::apiregistry::v1::CloudApiRegistry::StubInterface> + grpc_stub_; + std::unique_ptr + locations_stub_; +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.cc new file mode 100644 index 0000000000000..6c84f5c85cd62 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.cc @@ -0,0 +1,75 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_auth_decorator.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_logging_decorator.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_metadata_decorator.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h" +#include "google/cloud/common_options.h" +#include "google/cloud/grpc_options.h" +#include "google/cloud/internal/algorithm.h" +#include "google/cloud/internal/opentelemetry.h" +#include "google/cloud/log.h" +#include "google/cloud/options.h" +#include +#include +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +std::shared_ptr CreateDefaultCloudApiRegistryStub( + std::shared_ptr auth, + Options const& options) { + auto channel = auth->CreateChannel(options.get(), + internal::MakeChannelArguments(options)); + auto service_grpc_stub = + google::cloud::apiregistry::v1::CloudApiRegistry::NewStub(channel); + auto service_locations_stub = + google::cloud::location::Locations::NewStub(channel); + std::shared_ptr stub = + std::make_shared( + std::move(service_grpc_stub), std::move(service_locations_stub)); + + if (auth->RequiresConfigureContext()) { + stub = std::make_shared(std::move(auth), + std::move(stub)); + } + stub = std::make_shared( + std::move(stub), std::multimap{}); + if (internal::Contains(options.get(), "rpc")) { + GCP_LOG(INFO) << "Enabled logging for gRPC calls"; + stub = std::make_shared( + std::move(stub), options.get(), + options.get()); + } + if (internal::TracingEnabled(options)) { + stub = MakeCloudApiRegistryTracingStub(std::move(stub)); + } + return stub; +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h new file mode 100644 index 0000000000000..7885509c78c21 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_stub_factory.h @@ -0,0 +1,42 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_FACTORY_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_FACTORY_H + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/internal/unified_grpc_credentials.h" +#include "google/cloud/options.h" +#include "google/cloud/version.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +std::shared_ptr CreateDefaultCloudApiRegistryStub( + std::shared_ptr auth, + Options const& options); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_STUB_FACTORY_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.cc new file mode 100644 index 0000000000000..9202a283928e2 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.cc @@ -0,0 +1,113 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h" +#include "google/cloud/internal/opentelemetry.h" +#include "google/cloud/internal/traced_stream_range.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +CloudApiRegistryTracingConnection::CloudApiRegistryTracingConnection( + std::shared_ptr child) + : child_(std::move(child)) {} + +StatusOr +CloudApiRegistryTracingConnection::GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::GetMcpServer"); + auto scope = opentelemetry::trace::Scope(span); + return internal::EndSpan(*span, child_->GetMcpServer(request)); +} + +StreamRange +CloudApiRegistryTracingConnection::ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::ListMcpServers"); + internal::OTelScope scope(span); + auto sr = child_->ListMcpServers(std::move(request)); + return internal::MakeTracedStreamRange< + google::cloud::apiregistry::v1::McpServer>(std::move(span), + std::move(sr)); +} + +StatusOr +CloudApiRegistryTracingConnection::GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::GetMcpTool"); + auto scope = opentelemetry::trace::Scope(span); + return internal::EndSpan(*span, child_->GetMcpTool(request)); +} + +StreamRange +CloudApiRegistryTracingConnection::ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::ListMcpTools"); + internal::OTelScope scope(span); + auto sr = child_->ListMcpTools(std::move(request)); + return internal::MakeTracedStreamRange< + google::cloud::apiregistry::v1::McpTool>(std::move(span), std::move(sr)); +} + +StreamRange +CloudApiRegistryTracingConnection::ListLocations( + google::cloud::location::ListLocationsRequest request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::ListLocations"); + internal::OTelScope scope(span); + auto sr = child_->ListLocations(std::move(request)); + return internal::MakeTracedStreamRange( + std::move(span), std::move(sr)); +} + +StatusOr +CloudApiRegistryTracingConnection::GetLocation( + google::cloud::location::GetLocationRequest const& request) { + auto span = internal::MakeSpan( + "apiregistry_v1::CloudApiRegistryConnection::GetLocation"); + auto scope = opentelemetry::trace::Scope(span); + return internal::EndSpan(*span, child_->GetLocation(request)); +} + +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +std::shared_ptr +MakeCloudApiRegistryTracingConnection( + std::shared_ptr conn) { +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + if (internal::TracingEnabled(conn->options())) { + conn = std::make_shared(std::move(conn)); + } +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + return conn; +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h new file mode 100644 index 0000000000000..a9b53c8bf117a --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_connection.h @@ -0,0 +1,84 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_CONNECTION_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_CONNECTION_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include "google/cloud/version.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +class CloudApiRegistryTracingConnection + : public apiregistry_v1::CloudApiRegistryConnection { + public: + ~CloudApiRegistryTracingConnection() override = default; + + explicit CloudApiRegistryTracingConnection( + std::shared_ptr child); + + Options options() override { return child_->options(); } + + StatusOr GetMcpServer( + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StreamRange ListMcpServers( + google::cloud::apiregistry::v1::ListMcpServersRequest request) override; + + StatusOr GetMcpTool( + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StreamRange ListMcpTools( + google::cloud::apiregistry::v1::ListMcpToolsRequest request) override; + + StreamRange ListLocations( + google::cloud::location::ListLocationsRequest request) override; + + StatusOr GetLocation( + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::shared_ptr child_; +}; + +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +/** + * Conditionally applies the tracing decorator to the given connection. + * + * The connection is only decorated if tracing is enabled (as determined by the + * connection's options). + */ +std::shared_ptr +MakeCloudApiRegistryTracingConnection( + std::shared_ptr conn); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_CONNECTION_H diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.cc b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.cc new file mode 100644 index 0000000000000..06b5454f5fafc --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.cc @@ -0,0 +1,121 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h" +#include "google/cloud/internal/grpc_opentelemetry.h" +#include +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +CloudApiRegistryTracingStub::CloudApiRegistryTracingStub( + std::shared_ptr child) + : child_(std::move(child)), propagator_(internal::MakePropagator()) {} + +StatusOr +CloudApiRegistryTracingStub::GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "GetMcpServer"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->GetMcpServer(context, options, request)); +} + +StatusOr +CloudApiRegistryTracingStub::ListMcpServers( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "ListMcpServers"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->ListMcpServers(context, options, request)); +} + +StatusOr +CloudApiRegistryTracingStub::GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "GetMcpTool"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->GetMcpTool(context, options, request)); +} + +StatusOr +CloudApiRegistryTracingStub::ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "ListMcpTools"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->ListMcpTools(context, options, request)); +} + +StatusOr +CloudApiRegistryTracingStub::ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "ListLocations"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->ListLocations(context, options, request)); +} + +StatusOr +CloudApiRegistryTracingStub::GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) { + auto span = internal::MakeSpanGrpc( + "google.cloud.apiregistry.v1.CloudApiRegistry", "GetLocation"); + auto scope = opentelemetry::trace::Scope(span); + internal::InjectTraceContext(context, *propagator_); + return internal::EndSpan(context, *span, + child_->GetLocation(context, options, request)); +} + +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +std::shared_ptr MakeCloudApiRegistryTracingStub( + std::shared_ptr stub) { +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + return std::make_shared(std::move(stub)); +#else + return stub; +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY +} + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google diff --git a/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h new file mode 100644 index 0000000000000..f684b07836511 --- /dev/null +++ b/google/cloud/apiregistry/v1/internal/cloud_api_registry_tracing_stub.h @@ -0,0 +1,92 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_STUB_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_STUB_H + +#include "google/cloud/apiregistry/v1/internal/cloud_api_registry_stub.h" +#include "google/cloud/internal/trace_propagator.h" +#include "google/cloud/options.h" +#include "google/cloud/version.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_internal { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +#ifdef GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +class CloudApiRegistryTracingStub : public CloudApiRegistryStub { + public: + ~CloudApiRegistryTracingStub() override = default; + + explicit CloudApiRegistryTracingStub( + std::shared_ptr child); + + StatusOr GetMcpServer( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpServerRequest const& request) + override; + + StatusOr + ListMcpServers(grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpServersRequest const& + request) override; + + StatusOr GetMcpTool( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::GetMcpToolRequest const& request) + override; + + StatusOr ListMcpTools( + grpc::ClientContext& context, Options const& options, + google::cloud::apiregistry::v1::ListMcpToolsRequest const& request) + override; + + StatusOr ListLocations( + grpc::ClientContext& context, Options const& options, + google::cloud::location::ListLocationsRequest const& request) override; + + StatusOr GetLocation( + grpc::ClientContext& context, Options const& options, + google::cloud::location::GetLocationRequest const& request) override; + + private: + std::shared_ptr child_; + std::shared_ptr + propagator_; +}; + +#endif // GOOGLE_CLOUD_CPP_HAVE_OPENTELEMETRY + +/** + * Applies the tracing decorator to the given stub. + * + * The stub is only decorated if the library has been compiled with + * OpenTelemetry. + */ +std::shared_ptr MakeCloudApiRegistryTracingStub( + std::shared_ptr stub); + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_internal +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_INTERNAL_CLOUD_API_REGISTRY_TRACING_STUB_H diff --git a/google/cloud/apiregistry/v1/mocks/mock_cloud_api_registry_connection.h b/google/cloud/apiregistry/v1/mocks/mock_cloud_api_registry_connection.h new file mode 100644 index 0000000000000..cdddc1a9c0176 --- /dev/null +++ b/google/cloud/apiregistry/v1/mocks/mock_cloud_api_registry_connection.h @@ -0,0 +1,84 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_MOCKS_MOCK_CLOUD_API_REGISTRY_CONNECTION_H +#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_MOCKS_MOCK_CLOUD_API_REGISTRY_CONNECTION_H + +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection.h" +#include + +namespace google { +namespace cloud { +namespace apiregistry_v1_mocks { +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN + +/** + * A class to mock `CloudApiRegistryConnection`. + * + * Application developers may want to test their code with simulated responses, + * including errors, from an object of type `CloudApiRegistryClient`. To do so, + * construct an object of type `CloudApiRegistryClient` with an instance of this + * class. Then use the Google Test framework functions to program the behavior + * of this mock. + * + * @see [This example][bq-mock] for how to test your application with GoogleTest. + * While the example showcases types from the BigQuery library, the underlying + * principles apply for any pair of `*Client` and `*Connection`. + * + * [bq-mock]: @cloud_cpp_docs_link{bigquery,bigquery-read-mock} + */ +class MockCloudApiRegistryConnection + : public apiregistry_v1::CloudApiRegistryConnection { + public: + MOCK_METHOD(Options, options, (), (override)); + + MOCK_METHOD( + StatusOr, GetMcpServer, + (google::cloud::apiregistry::v1::GetMcpServerRequest const& request), + (override)); + + MOCK_METHOD((StreamRange), + ListMcpServers, + (google::cloud::apiregistry::v1::ListMcpServersRequest request), + (override)); + + MOCK_METHOD( + StatusOr, GetMcpTool, + (google::cloud::apiregistry::v1::GetMcpToolRequest const& request), + (override)); + + MOCK_METHOD((StreamRange), + ListMcpTools, + (google::cloud::apiregistry::v1::ListMcpToolsRequest request), + (override)); + + MOCK_METHOD((StreamRange), ListLocations, + (google::cloud::location::ListLocationsRequest request), + (override)); + + MOCK_METHOD(StatusOr, GetLocation, + (google::cloud::location::GetLocationRequest const& request), + (override)); +}; + +GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END +} // namespace apiregistry_v1_mocks +} // namespace cloud +} // namespace google + +#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_APIREGISTRY_V1_MOCKS_MOCK_CLOUD_API_REGISTRY_CONNECTION_H diff --git a/google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc b/google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc new file mode 100644 index 0000000000000..a5fd51c60ad91 --- /dev/null +++ b/google/cloud/apiregistry/v1/samples/cloud_api_registry_client_samples.cc @@ -0,0 +1,186 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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. + +// Generated by the Codegen C++ plugin. +// If you make any local changes, they will be lost. +// source: google/cloud/apiregistry/v1/service.proto + +#include "google/cloud/apiregistry/v1/cloud_api_registry_client.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_connection_idempotency_policy.h" +#include "google/cloud/apiregistry/v1/cloud_api_registry_options.h" +#include "google/cloud/common_options.h" +#include "google/cloud/credentials.h" +#include "google/cloud/internal/getenv.h" +#include "google/cloud/testing_util/example_driver.h" +#include "google/cloud/universe_domain.h" +#include +#include +#include +#include + +// clang-format off +// main-dox-marker: apiregistry_v1::CloudApiRegistryClient +// clang-format on +namespace { + +void SetClientEndpoint(std::vector const& argv) { + if (!argv.empty()) { + throw google::cloud::testing_util::Usage{"set-client-endpoint"}; + } + //! [set-client-endpoint] + // This configuration is common with Private Google Access: + // https://cloud.google.com/vpc/docs/private-google-access + auto options = google::cloud::Options{}.set( + "private.googleapis.com"); + auto vpc_client = google::cloud::apiregistry_v1::CloudApiRegistryClient( + google::cloud::apiregistry_v1::MakeCloudApiRegistryConnection(options)); + //! [set-client-endpoint] +} + +void SetClientUniverseDomain(std::vector const& argv) { + if (!argv.empty()) { + throw google::cloud::testing_util::Usage{"set-client-universe-domain"}; + } + //! [set-client-universe-domain] + google::cloud::Options options; + + // AddUniverseDomainOption interrogates the UnifiedCredentialsOption, if set, + // in the provided Options for the Universe Domain associated with the + // credentials and adds it to the set of Options. + // If no UnifiedCredentialsOption is set, GoogleDefaultCredentials are used. + auto ud_options = google::cloud::AddUniverseDomainOption(std::move(options)); + + if (!ud_options.ok()) throw std::move(ud_options).status(); + auto ud_client = google::cloud::apiregistry_v1::CloudApiRegistryClient( + google::cloud::apiregistry_v1::MakeCloudApiRegistryConnection( + *ud_options)); + //! [set-client-universe-domain] +} + +//! [custom-idempotency-policy] +class CustomIdempotencyPolicy + : public google::cloud::apiregistry_v1:: + CloudApiRegistryConnectionIdempotencyPolicy { + public: + ~CustomIdempotencyPolicy() override = default; + std::unique_ptr + clone() const override { + return std::make_unique(*this); + } + // Override inherited functions to define as needed. +}; +//! [custom-idempotency-policy] + +void SetRetryPolicy(std::vector const& argv) { + if (!argv.empty()) { + throw google::cloud::testing_util::Usage{"set-client-retry-policy"}; + } + //! [set-retry-policy] + auto options = + google::cloud::Options{} + .set( + CustomIdempotencyPolicy().clone()) + .set< + google::cloud::apiregistry_v1::CloudApiRegistryRetryPolicyOption>( + google::cloud::apiregistry_v1:: + CloudApiRegistryLimitedErrorCountRetryPolicy(3) + .clone()) + .set( + google::cloud::ExponentialBackoffPolicy( + /*initial_delay=*/std::chrono::milliseconds(200), + /*maximum_delay=*/std::chrono::seconds(45), + /*scaling=*/2.0) + .clone()); + auto connection = + google::cloud::apiregistry_v1::MakeCloudApiRegistryConnection(options); + + // c1 and c2 share the same retry policies + auto c1 = google::cloud::apiregistry_v1::CloudApiRegistryClient(connection); + auto c2 = google::cloud::apiregistry_v1::CloudApiRegistryClient(connection); + + // You can override any of the policies in a new client. This new client + // will share the policies from c1 (or c2) *except* for the retry policy. + auto c3 = google::cloud::apiregistry_v1::CloudApiRegistryClient( + connection, + google::cloud::Options{} + .set< + google::cloud::apiregistry_v1::CloudApiRegistryRetryPolicyOption>( + google::cloud::apiregistry_v1:: + CloudApiRegistryLimitedTimeRetryPolicy( + std::chrono::minutes(5)) + .clone())); + + // You can also override the policies in a single call: + // c3.SomeRpc(..., google::cloud::Options{} + // .set( + // google::cloud::apiregistry_v1::CloudApiRegistryLimitedErrorCountRetryPolicy(10).clone())); + //! [set-retry-policy] +} + +void WithServiceAccount(std::vector const& argv) { + if (argv.size() != 1 || argv[0] == "--help") { + throw google::cloud::testing_util::Usage{"with-service-account "}; + } + //! [with-service-account] + [](std::string const& keyfile) { + auto is = std::ifstream(keyfile); + is.exceptions(std::ios::badbit); // Minimal error handling in examples + auto contents = std::string(std::istreambuf_iterator(is.rdbuf()), {}); + auto options = + google::cloud::Options{}.set( + google::cloud::MakeServiceAccountCredentials(contents)); + return google::cloud::apiregistry_v1::CloudApiRegistryClient( + google::cloud::apiregistry_v1::MakeCloudApiRegistryConnection(options)); + } + //! [with-service-account] + (argv.at(0)); +} + +void AutoRun(std::vector const& argv) { + namespace examples = ::google::cloud::testing_util; + using ::google::cloud::internal::GetEnv; + if (!argv.empty()) throw examples::Usage{"auto"}; + examples::CheckEnvironmentVariablesAreSet( + {"GOOGLE_CLOUD_CPP_TEST_SERVICE_ACCOUNT_KEYFILE"}); + auto const keyfile = + GetEnv("GOOGLE_CLOUD_CPP_TEST_SERVICE_ACCOUNT_KEYFILE").value(); + + std::cout << "\nRunning SetClientEndpoint() example" << std::endl; + SetClientEndpoint({}); + + std::cout << "\nRunning SetRetryPolicy() example" << std::endl; + SetRetryPolicy({}); + + std::cout << "\nRunning WithServiceAccount() example" << std::endl; + WithServiceAccount({keyfile}); + + std::cout << "\nRunning SetClientUniverseDomain() example" << std::endl; + SetClientUniverseDomain({}); +} + +} // namespace + +int main(int argc, char* argv[]) { // NOLINT(bugprone-exception-escape) + google::cloud::testing_util::Example example({ + {"set-client-endpoint", SetClientEndpoint}, + {"set-retry-policy", SetRetryPolicy}, + {"with-service-account", WithServiceAccount}, + {"set-client-universe-domain", SetClientUniverseDomain}, + {"auto", AutoRun}, + }); + return example.Run(argc, argv); +} From afb69ea494fbbb221a86fd704af8f0045af80c53 Mon Sep 17 00:00:00 2001 From: Scott Hart Date: Thu, 5 Feb 2026 13:37:12 -0500 Subject: [PATCH 3/6] Add API baseline --- ..._cloud_cpp_apiregistry.expected.abi.dump.gz | Bin 0 -> 377120 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 ci/abi-dumps/google_cloud_cpp_apiregistry.expected.abi.dump.gz diff --git a/ci/abi-dumps/google_cloud_cpp_apiregistry.expected.abi.dump.gz b/ci/abi-dumps/google_cloud_cpp_apiregistry.expected.abi.dump.gz new file mode 100644 index 0000000000000000000000000000000000000000..2979b3345bf593b05036a54a7bfa9fa3a4555ee9 GIT binary patch literal 377120 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