diff --git a/CHANGELOG.md b/CHANGELOG.md index 439bd6ae9f79f..568142c8e6fe4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ breaking changes in the upcoming 3.x release. This release is scheduled for We are happy to announce the following GA libraries. Unless specifically noted, the APIs in these libraries are stable, and are ready for production use. +- [Cloud API Registry](google/cloud/apiregistry/README.md) - [Audit Manager](/google/cloud/auditmanager/README.md) ## v2.46.0 - 2026-01 diff --git a/README.md b/README.md index ea1c3306c7adb..8dfa9cd6e2cb4 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/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 0000000000000..2979b3345bf59 Binary files /dev/null and b/ci/abi-dumps/google_cloud_cpp_apiregistry.expected.abi.dump.gz differ diff --git a/ci/etc/expected_install_directories b/ci/etc/expected_install_directories index db0af4607fbd5..7746f661c50c4 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 @@ -1363,6 +1367,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/cmake/GoogleCloudCppFeatures.cmake b/cmake/GoogleCloudCppFeatures.cmake index af722274e0592..2eed8b78378c8 100644 --- a/cmake/GoogleCloudCppFeatures.cmake +++ b/cmake/GoogleCloudCppFeatures.cmake @@ -49,6 +49,7 @@ set(GOOGLE_CLOUD_CPP_GA_LIBRARIES "apigateway" "apigeeconnect" "apikeys" + "apiregistry" "appengine" "apphub" "artifactregistry" 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/external/googleapis/update_libraries.sh b/external/googleapis/update_libraries.sh index 7019a0b6006d6..3f6aacec83d0b 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 c4ec62136ff3e..aafd8fdbe2d6c 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" 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..e1a141fc6e856 --- /dev/null +++ b/google/cloud/apiregistry/CMakeLists.txt @@ -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. +# ~~~ + +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) + set_tests_properties( + apiregistry_quickstart + PROPERTIES LABELS "integration-test;quickstart" PASS_REGULAR_EXPRESSION + "Permanent error.*gcloud-cpp.retry.function=ListMcpServers") +endif () diff --git a/google/cloud/apiregistry/README.md b/google/cloud/apiregistry/README.md new file mode 100644 index 0000000000000..36e07c8d5e394 --- /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/cloud_api_registry_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::CloudApiRegistryClient( + apiregistry::MakeCloudApiRegistryConnection()); + + for (auto r : client.ListMcpServers(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..f418b5f71be1f --- /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/cloud_api_registry_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::CloudApiRegistryClient( + apiregistry::MakeCloudApiRegistryConnection()); + + for (auto r : client.ListMcpServers(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); +} diff --git a/libraries.bzl b/libraries.bzl index 24fefa5e8d7a7..8a46d0cab1272 100644 --- a/libraries.bzl +++ b/libraries.bzl @@ -33,6 +33,7 @@ GOOGLE_CLOUD_CPP_GA_LIBRARIES = [ "apigateway", "apigeeconnect", "apikeys", + "apiregistry", "appengine", "apphub", "artifactregistry",