grpc 1.47.0 → 1.49.0.pre1

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -197,7 +197,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -224,7 +224,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return GRPC_ERROR_NONE;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   grpc_error_set_int(
       grpc_error_set_str(
@@ -267,7 +267,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) goto failure;
+  if (!GRPC_ERROR_IS_NONE(error)) goto failure;
 
   /* Start the "accept" asynchronously. */
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
@@ -292,7 +292,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -316,7 +316,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   /* The general mechanism for shutting down is to queue abortion calls. While
      this is necessary in the read/write case, it's useless for the accept
      case. We only need to adjust the pending callback count */
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
             grpc_error_std_string(error).c_str());
 
@@ -419,7 +419,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   }
 
   error = prepare_socket(sock, addr, &port);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
 
@@ -511,7 +511,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
 done:
   gpr_free(allocated_addr);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to add port to server", &error, 1);

data/src/core/lib/iomgr/tcp_windows.cc

@@ -89,11 +89,11 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock) {
   grpc_error_handle err;
   err = grpc_tcp_set_non_block(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = set_dualstack(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = enable_socket_low_latency(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   return GRPC_ERROR_NONE;
 }
 
@@ -186,7 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   (void)GRPC_ERROR_REF(error);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
       char* utf8_message = gpr_format_message(info->wsa_error);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(utf8_message);
@@ -331,7 +331,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   tcp->write_cb = NULL;
   gpr_mu_unlock(&tcp->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {

data/src/core/lib/iomgr/timer_generic.cc

@@ -33,10 +33,11 @@
 #include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/time_averaged_stats.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/time_averaged_stats.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
 
@@ -60,7 +61,7 @@ grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
  */
 struct timer_shard {
   gpr_mu mu;
-  grpc_time_averaged_stats stats;
+  grpc_core::ManualConstructor<grpc_core::TimeAveragedStats> stats;
   /* All and only timers with deadlines < this will be in the heap. */
   grpc_core::Timestamp queue_deadline_cap;
   /* The deadline of the next timer due in this shard. */
@@ -259,8 +260,7 @@ static void timer_list_init() {
   for (i = 0; i < g_num_shards; i++) {
     timer_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
-    grpc_time_averaged_stats_init(&shard->stats, 1.0 / ADD_DEADLINE_SCALE, 0.1,
-                                  0.5);
+    shard->stats.Init(1.0 / ADD_DEADLINE_SCALE, 0.1, 0.5);
     shard->queue_deadline_cap = g_shared_mutables.min_timer;
     shard->shard_queue_index = i;
     grpc_timer_heap_init(&shard->heap);
@@ -367,8 +367,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     return;
   }
 
-  grpc_time_averaged_stats_add_sample(&shard->stats,
-                                      (deadline - now).millis() / 1000.0);
+  shard->stats->AddSample((deadline - now).millis() / 1000.0);
 
   ADD_TO_HASH_TABLE(timer);
 
@@ -473,8 +472,7 @@ static void timer_cancel(grpc_timer* timer) {
 static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
   /* Compute the new queue window width and bound by the limits: */
   double computed_deadline_delta =
-      grpc_time_averaged_stats_update_average(&shard->stats) *
-      ADD_DEADLINE_SCALE;
+      shard->stats->UpdateAverage() * ADD_DEADLINE_SCALE;
   double deadline_delta =
       grpc_core::Clamp(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
                        MAX_QUEUE_WINDOW_DURATION);

data/src/core/lib/iomgr/unix_sockets_posix.cc

@@ -45,7 +45,7 @@ absl::StatusOr<std::vector<grpc_resolved_address>>
 grpc_resolve_unix_domain_address(absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error = grpc_core::UnixSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);
@@ -58,7 +58,7 @@ grpc_resolve_unix_abstract_domain_address(const absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);

data/src/core/lib/iomgr/wakeup_fd_pipe.cc

@@ -41,9 +41,9 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return GRPC_ERROR_NONE;

data/src/core/lib/iomgr/wakeup_fd_posix.cc

@@ -32,22 +32,25 @@ static const grpc_wakeup_fd_vtable* wakeup_fd_vtable = nullptr;
 int grpc_allow_specialized_wakeup_fd = 1;
 int grpc_allow_pipe_wakeup_fd = 1;
 
-int has_real_wakeup_fd = 1;
-int cv_wakeup_fds_enabled = 0;
+static int has_real_wakeup_fd = 1;
+
+static gpr_once once_init_wakeup_fd = GPR_ONCE_INIT;
 
 void grpc_wakeup_fd_global_init(void) {
-  if (grpc_allow_specialized_wakeup_fd &&
-      grpc_specialized_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
-  } else if (grpc_allow_pipe_wakeup_fd &&
-             grpc_pipe_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
-  } else {
-    has_real_wakeup_fd = 0;
-  }
+  gpr_once_init(&once_init_wakeup_fd, []() {
+    if (grpc_allow_specialized_wakeup_fd &&
+        grpc_specialized_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
+    } else if (grpc_allow_pipe_wakeup_fd &&
+               grpc_pipe_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
+    } else {
+      has_real_wakeup_fd = 0;
+    }
+  });
 }
 
-void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
+void grpc_wakeup_fd_global_destroy(void) {}
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -59,8 +59,6 @@ void grpc_wakeup_fd_global_destroy(void);
 void grpc_wakeup_fd_global_init_force_fallback(void);
 
 int grpc_has_wakeup_fd(void);
-int grpc_cv_wakeup_fds_enabled(void);
-void grpc_enable_cv_wakeup_fds(int enable);
 
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 

data/src/core/lib/json/json.h

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 
 #ifndef GRPC_CORE_LIB_JSON_JSON_H
 #define GRPC_CORE_LIB_JSON_JSON_H
@@ -26,10 +24,9 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/error.h"
-
 namespace grpc_core {
 
 // A JSON value, which can be any one of object, array, string,
@@ -54,8 +51,8 @@ class Json {
   using Object = std::map<std::string, Json>;
   using Array = std::vector<Json>;
 
-  // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(absl::string_view json_str, grpc_error_handle* error);
+  // Parses JSON string from json_str.
+  static absl::StatusOr<Json> Parse(absl::string_view json_str);
 
   Json() = default;
 
@@ -246,4 +243,4 @@ class Json {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_JSON_JSON_H */
+#endif  // GRPC_CORE_LIB_JSON_JSON_H

data/src/core/lib/json/json_args.h

@@ -0,0 +1,34 @@
+// Copyright 2020 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_JSON_JSON_ARGS_H
+#define GRPC_CORE_LIB_JSON_JSON_ARGS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class JsonArgs {
+ public:
+  JsonArgs() = default;
+  virtual ~JsonArgs() = default;
+
+  virtual bool IsEnabled(absl::string_view /*key*/) const { return true; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_JSON_JSON_ARGS_H

data/src/core/lib/json/json_object_loader.cc

@@ -0,0 +1,233 @@
+// Copyright 2020 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/json/json_object_loader.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/strip.h"
+
+namespace grpc_core {
+
+void ErrorList::PushField(absl::string_view ext) {
+  // Skip leading '.' for top-level field names.
+  if (fields_.empty()) absl::ConsumePrefix(&ext, ".");
+  fields_.emplace_back(std::string(ext));
+}
+
+void ErrorList::PopField() { fields_.pop_back(); }
+
+void ErrorList::AddError(absl::string_view error) {
+  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
+}
+
+bool ErrorList::FieldHasErrors() const {
+  return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
+}
+
+absl::Status ErrorList::status() const {
+  if (field_errors_.empty()) return absl::OkStatus();
+  std::vector<std::string> errors;
+  for (const auto& p : field_errors_) {
+    if (p.second.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
+                                       absl::StrJoin(p.second, "; "), "]"));
+    } else {
+      errors.emplace_back(
+          absl::StrCat("field:", p.first, " error:", p.second[0]));
+    }
+  }
+  return absl::InvalidArgumentError(absl::StrCat(
+      "errors validating JSON: [", absl::StrJoin(errors, "; "), "]"));
+}
+
+namespace json_detail {
+
+void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
+                          ErrorList* errors) const {
+  // We accept either STRING or NUMBER for numeric values, as per
+  // https://developers.google.com/protocol-buffers/docs/proto3#json.
+  if (json.type() != Json::Type::STRING &&
+      (!IsNumber() || json.type() != Json::Type::NUMBER)) {
+    errors->AddError(
+        absl::StrCat("is not a ", IsNumber() ? "number" : "string"));
+    return;
+  }
+  return LoadInto(json.string_value(), dst, errors);
+}
+
+bool LoadString::IsNumber() const { return false; }
+
+void LoadString::LoadInto(const std::string& value, void* dst,
+                          ErrorList*) const {
+  *static_cast<std::string*>(dst) = value;
+}
+
+bool LoadDuration::IsNumber() const { return false; }
+
+void LoadDuration::LoadInto(const std::string& value, void* dst,
+                            ErrorList* errors) const {
+  absl::string_view buf(value);
+  if (!absl::ConsumeSuffix(&buf, "s")) {
+    errors->AddError("Not a duration (no s suffix)");
+    return;
+  }
+  buf = absl::StripAsciiWhitespace(buf);
+  auto decimal_point = buf.find('.');
+  int nanos = 0;
+  if (decimal_point != absl::string_view::npos) {
+    absl::string_view after_decimal = buf.substr(decimal_point + 1);
+    buf = buf.substr(0, decimal_point);
+    if (!absl::SimpleAtoi(after_decimal, &nanos)) {
+      errors->AddError("Not a duration (not a number of nanoseconds)");
+      return;
+    }
+    if (after_decimal.length() > 9) {
+      // We don't accept greater precision than nanos.
+      errors->AddError("Not a duration (too many digits after decimal)");
+      return;
+    }
+    for (size_t i = 0; i < (9 - after_decimal.length()); ++i) {
+      nanos *= 10;
+    }
+  }
+  int seconds;
+  if (!absl::SimpleAtoi(buf, &seconds)) {
+    errors->AddError("Not a duration (not a number of seconds)");
+    return;
+  }
+  *static_cast<Duration*>(dst) =
+      Duration::FromSecondsAndNanoseconds(seconds, nanos);
+}
+
+bool LoadNumber::IsNumber() const { return true; }
+
+void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
+                        ErrorList* errors) const {
+  if (json.type() == Json::Type::JSON_TRUE) {
+    *static_cast<bool*>(dst) = true;
+  } else if (json.type() == Json::Type::JSON_FALSE) {
+    *static_cast<bool*>(dst) = false;
+  } else {
+    errors->AddError("is not a boolean");
+  }
+}
+
+void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
+                                         void* dst, ErrorList* errors) const {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return;
+  }
+  *static_cast<Json::Object*>(dst) = json.object_value();
+}
+
+void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                          ErrorList* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  const auto& array = json.array_value();
+  const LoaderInterface* element_loader = ElementLoader();
+  for (size_t i = 0; i < array.size(); ++i) {
+    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    void* element = EmplaceBack(dst);
+    element_loader->LoadInto(array[i], args, element, errors);
+  }
+}
+
+void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
+                                             const JsonArgs& args, void* dst,
+                                             ErrorList* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  const auto& array = json.array_value();
+  const LoaderInterface* element_loader = LoaderForType<bool>();
+  std::vector<bool>* vec = static_cast<std::vector<bool>*>(dst);
+  for (size_t i = 0; i < array.size(); ++i) {
+    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    bool elem = false;
+    element_loader->LoadInto(array[i], args, &elem, errors);
+    vec->push_back(elem);
+  }
+}
+
+void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                       ErrorList* errors) const {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return;
+  }
+  const LoaderInterface* element_loader = ElementLoader();
+  for (const auto& pair : json.object_value()) {
+    ScopedField field(errors, absl::StrCat("[\"", pair.first, "\"]"));
+    void* element = Insert(pair.first, dst);
+    element_loader->LoadInto(pair.second, args, element, errors);
+  }
+}
+
+void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                            ErrorList* errors) const {
+  if (json.type() == Json::Type::JSON_NULL) return;
+  void* element = Emplace(dst);
+  ElementLoader()->LoadInto(json, args, element, errors);
+}
+
+bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
+                size_t num_elements, void* dst, ErrorList* errors) {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return false;
+  }
+  for (size_t i = 0; i < num_elements; ++i) {
+    const Element& element = elements[i];
+    if (element.enable_key != nullptr && !args.IsEnabled(element.enable_key)) {
+      continue;
+    }
+    ScopedField field(errors, absl::StrCat(".", element.name));
+    const auto& it = json.object_value().find(element.name);
+    if (it == json.object_value().end()) {
+      if (element.optional) continue;
+      errors->AddError("field not present");
+      continue;
+    }
+    char* field_dst = static_cast<char*>(dst) + element.member_offset;
+    element.loader->LoadInto(it->second, args, field_dst, errors);
+  }
+  return true;
+}
+
+const Json* GetJsonObjectField(const Json::Object& json,
+                               absl::string_view field, ErrorList* errors,
+                               bool required) {
+  auto it = json.find(std::string(field));
+  if (it == json.end()) {
+    if (required) errors->AddError("field not present");
+    return nullptr;
+  }
+  return &it->second;
+}
+
+}  // namespace json_detail
+}  // namespace grpc_core