1 //
2 //
3 // Copyright 2023 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include <grpc/support/port_platform.h>
20
21 #include "src/core/ext/gcp/metadata_query.h"
22
23 #include <string.h>
24
25 #include <initializer_list>
26 #include <memory>
27 #include <utility>
28
29 #include "absl/status/status.h"
30 #include "absl/status/statusor.h"
31 #include "absl/strings/str_format.h"
32 #include "absl/strings/string_view.h"
33
34 #include <grpc/grpc.h>
35 #include <grpc/grpc_security.h>
36 #include <grpc/support/log.h>
37
38 #include "src/core/lib/debug/trace.h"
39 #include "src/core/lib/gprpp/ref_counted_ptr.h"
40 #include "src/core/lib/gprpp/status_helper.h"
41 #include "src/core/lib/gprpp/time.h"
42 #include "src/core/lib/security/credentials/credentials.h"
43 #include "src/core/lib/uri/uri_parser.h"
44
45 namespace grpc_core {
46
47 TraceFlag grpc_metadata_query_trace(false, "metadata_query");
48
49 constexpr const char MetadataQuery::kZoneAttribute[];
50 constexpr const char MetadataQuery::kClusterNameAttribute[];
51 constexpr const char MetadataQuery::kRegionAttribute[];
52 constexpr const char MetadataQuery::kInstanceIdAttribute[];
53 constexpr const char MetadataQuery::kIPv6Attribute[];
54
MetadataQuery(std::string attribute,grpc_polling_entity * pollent,absl::AnyInvocable<void (std::string,absl::StatusOr<std::string>)> callback,Duration timeout)55 MetadataQuery::MetadataQuery(
56 std::string attribute, grpc_polling_entity* pollent,
57 absl::AnyInvocable<void(std::string /* attribute */,
58 absl::StatusOr<std::string> /* result */)>
59 callback,
60 Duration timeout)
61 : MetadataQuery("metadata.google.internal.", std::move(attribute), pollent,
62 std::move(callback), timeout) {}
63
MetadataQuery(std::string metadata_server_name,std::string attribute,grpc_polling_entity * pollent,absl::AnyInvocable<void (std::string,absl::StatusOr<std::string>)> callback,Duration timeout)64 MetadataQuery::MetadataQuery(
65 std::string metadata_server_name, std::string attribute,
66 grpc_polling_entity* pollent,
67 absl::AnyInvocable<void(std::string /* attribute */,
68 absl::StatusOr<std::string> /* result */)>
69 callback,
70 Duration timeout)
71 : InternallyRefCounted<MetadataQuery>(nullptr, 2),
72 attribute_(std::move(attribute)),
73 callback_(std::move(callback)) {
74 GRPC_CLOSURE_INIT(&on_done_, OnDone, this, nullptr);
75 auto uri = URI::Create("http", std::move(metadata_server_name), attribute_,
76 {} /* query params */, "" /* fragment */);
77 GPR_ASSERT(uri.ok()); // params are hardcoded
78 grpc_http_request request;
79 memset(&request, 0, sizeof(grpc_http_request));
80 grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
81 const_cast<char*>("Google")};
82 request.hdr_count = 1;
83 request.hdrs = &header;
84 http_request_ = HttpRequest::Get(
85 std::move(*uri), nullptr /* channel args */, pollent, &request,
86 Timestamp::Now() + timeout, &on_done_, &response_,
87 RefCountedPtr<grpc_channel_credentials>(
88 grpc_insecure_credentials_create()));
89 http_request_->Start();
90 }
91
~MetadataQuery()92 MetadataQuery::~MetadataQuery() { grpc_http_response_destroy(&response_); }
93
Orphan()94 void MetadataQuery::Orphan() {
95 http_request_.reset();
96 Unref();
97 }
98
OnDone(void * arg,grpc_error_handle error)99 void MetadataQuery::OnDone(void* arg, grpc_error_handle error) {
100 auto* self = static_cast<MetadataQuery*>(arg);
101 if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
102 gpr_log(GPR_INFO, "MetadataServer Query for %s: HTTP status: %d, error: %s",
103 self->attribute_.c_str(), self->response_.status,
104 StatusToString(error).c_str());
105 }
106 absl::StatusOr<std::string> result;
107 if (!error.ok()) {
108 result = absl::UnavailableError(absl::StrFormat(
109 "MetadataServer Query failed for %s: %s", self->attribute_.c_str(),
110 StatusToString(error).c_str()));
111 } else if (self->response_.status != 200) {
112 result = absl::UnavailableError(absl::StrFormat(
113 "MetadataServer Query received non-200 status for %s: %s",
114 self->attribute_.c_str(), StatusToString(error).c_str()));
115 } else if (self->attribute_ == kZoneAttribute) {
116 absl::string_view body(self->response_.body, self->response_.body_length);
117 size_t pos = body.find_last_of('/');
118 if (pos == body.npos) {
119 result = absl::UnavailableError(
120 absl::StrFormat("MetadataServer Could not parse zone: %s",
121 std::string(body).c_str()));
122 if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
123 gpr_log(GPR_INFO, "%s", result.status().ToString().c_str());
124 }
125 } else {
126 result = std::string(body.substr(pos + 1));
127 }
128 } else {
129 result = std::string(self->response_.body, self->response_.body_length);
130 }
131 auto callback = std::move(self->callback_);
132 auto attribute = std::move(self->attribute_);
133 self->Unref();
134 return callback(std::move(attribute), std::move(result));
135 }
136
137 } // namespace grpc_core
138