grpc 1.10.0 → 1.11.0.pre2

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

@@ -1,284 +0,0 @@
-/*
- *
- * Copyright 2016 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 "src/core/lib/iomgr/port.h"
-#ifdef GRPC_UV
-
-#include <uv.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/host_port.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/iomgr_uv.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
-
-#include <string.h>
-
-typedef struct request {
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addresses;
-  struct addrinfo* hints;
-  char* host;
-  char* port;
-} request;
-
-static int retry_named_port_failure(int status, request* r,
-                                    uv_getaddrinfo_cb getaddrinfo_cb) {
-  if (status != 0) {
-    // This loop is copied from resolve_address_posix.c
-    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (strcmp(r->port, svc[i][0]) == 0) {
-        int retry_status;
-        uv_getaddrinfo_t* req =
-            (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
-        req->data = r;
-        r->port = gpr_strdup(svc[i][1]);
-        retry_status = uv_getaddrinfo(uv_default_loop(), req, getaddrinfo_cb,
-                                      r->host, r->port, r->hints);
-        if (retry_status < 0 || getaddrinfo_cb == NULL) {
-          // The callback will not be called
-          gpr_free(req);
-        }
-        return retry_status;
-      }
-    }
-  }
-  /* If this function calls uv_getaddrinfo, it will return that function's
-     return value. That function only returns numbers <=0, so we can safely
-     return 1 to indicate that we never retried */
-  return 1;
-}
-
-static grpc_error* handle_addrinfo_result(int status, struct addrinfo* result,
-                                          grpc_resolved_addresses** addresses) {
-  struct addrinfo* resp;
-  size_t i;
-  if (status != 0) {
-    grpc_error* error;
-    *addresses = NULL;
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("getaddrinfo failed");
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                           grpc_slice_from_static_string(uv_strerror(status)));
-    return error;
-  }
-  (*addresses) =
-      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
-  (*addresses)->naddrs = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
-    (*addresses)->naddrs++;
-  }
-  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
-      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
-  i = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
-    memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
-    (*addresses)->addrs[i].len = resp->ai_addrlen;
-    i++;
-  }
-
-  {
-    for (i = 0; i < (*addresses)->naddrs; i++) {
-      char* buf;
-      grpc_sockaddr_to_string(&buf, &(*addresses)->addrs[i], 0);
-      gpr_free(buf);
-    }
-  }
-  return GRPC_ERROR_NONE;
-}
-
-static void getaddrinfo_callback(uv_getaddrinfo_t* req, int status,
-                                 struct addrinfo* res) {
-  request* r = (request*)req->data;
-  grpc_core::ExecCtx exec_ctx;
-  grpc_error* error;
-  int retry_status;
-  char* port = r->port;
-
-  gpr_free(req);
-  retry_status = retry_named_port_failure(status, r, getaddrinfo_callback);
-  if (retry_status == 0) {
-    /* The request is being retried. It is using its own port string, so we free
-     * the original one */
-    gpr_free(port);
-    return;
-  }
-  /* Either no retry was attempted, or the retry failed. Either way, the
-     original error probably has more interesting information */
-  error = handle_addrinfo_result(status, res, r->addresses);
-  GRPC_CLOSURE_SCHED(r->on_done, error);
-
-  gpr_free(r->hints);
-  gpr_free(r->host);
-  gpr_free(r->port);
-  gpr_free(r);
-  uv_freeaddrinfo(res);
-}
-
-static grpc_error* try_split_host_port(const char* name,
-                                       const char* default_port, char** host,
-                                       char** port) {
-  /* parse name, splitting it into host and port parts */
-  grpc_error* error;
-  gpr_split_host_port(name, host, port);
-  if (*host == NULL) {
-    char* msg;
-    gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return error;
-  }
-  if (*port == NULL) {
-    // TODO(murgatroid99): add tests for this case
-    if (default_port == NULL) {
-      char* msg;
-      gpr_asprintf(&msg, "no port in name '%s'", name);
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return error;
-    }
-    *port = gpr_strdup(default_port);
-  }
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error* blocking_resolve_address_impl(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  char* host;
-  char* port;
-  struct addrinfo hints;
-  uv_getaddrinfo_t req;
-  int s;
-  grpc_error* err;
-  int retry_status;
-  request r;
-
-  GRPC_UV_ASSERT_SAME_THREAD();
-
-  req.addrinfo = NULL;
-
-  err = try_split_host_port(name, default_port, &host, &port);
-  if (err != GRPC_ERROR_NONE) {
-    goto done;
-  }
-
-  /* Call getaddrinfo */
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
-  hints.ai_socktype = SOCK_STREAM; /* stream socket */
-  hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
-
-  s = uv_getaddrinfo(uv_default_loop(), &req, NULL, host, port, &hints);
-  r.addresses = addresses;
-  r.hints = &hints;
-  r.host = host;
-  r.port = port;
-  retry_status = retry_named_port_failure(s, &r, NULL);
-  if (retry_status <= 0) {
-    s = retry_status;
-  }
-  err = handle_addrinfo_result(s, req.addrinfo, addresses);
-
-done:
-  gpr_free(host);
-  gpr_free(port);
-  if (req.addrinfo) {
-    uv_freeaddrinfo(req.addrinfo);
-  }
-  return err;
-}
-
-grpc_error* (*grpc_blocking_resolve_address)(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) = blocking_resolve_address_impl;
-
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addrs) {
-  if (addrs != NULL) {
-    gpr_free(addrs->addrs);
-  }
-  gpr_free(addrs);
-}
-
-static void resolve_address_impl(const char* name, const char* default_port,
-                                 grpc_pollset_set* interested_parties,
-                                 grpc_closure* on_done,
-                                 grpc_resolved_addresses** addrs) {
-  uv_getaddrinfo_t* req = NULL;
-  request* r = NULL;
-  struct addrinfo* hints = NULL;
-  char* host = NULL;
-  char* port = NULL;
-  grpc_error* err;
-  int s;
-  GRPC_UV_ASSERT_SAME_THREAD();
-  err = try_split_host_port(name, default_port, &host, &port);
-  if (err != GRPC_ERROR_NONE) {
-    GRPC_CLOSURE_SCHED(on_done, err);
-    gpr_free(host);
-    gpr_free(port);
-    return;
-  }
-  r = (request*)gpr_malloc(sizeof(request));
-  r->on_done = on_done;
-  r->addresses = addrs;
-  r->host = host;
-  r->port = port;
-  req = (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
-  req->data = r;
-
-  /* Call getaddrinfo */
-  hints = (addrinfo*)gpr_malloc(sizeof(struct addrinfo));
-  memset(hints, 0, sizeof(struct addrinfo));
-  hints->ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
-  hints->ai_socktype = SOCK_STREAM; /* stream socket */
-  hints->ai_flags = AI_PASSIVE;     /* for wildcard IP address */
-  r->hints = hints;
-
-  s = uv_getaddrinfo(uv_default_loop(), req, getaddrinfo_callback, host, port,
-                     hints);
-
-  if (s != 0) {
-    *addrs = NULL;
-    err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("getaddrinfo failed");
-    err = grpc_error_set_str(err, GRPC_ERROR_STR_OS_ERROR,
-                             grpc_slice_from_static_string(uv_strerror(s)));
-    GRPC_CLOSURE_SCHED(on_done, err);
-    gpr_free(r);
-    gpr_free(req);
-    gpr_free(hints);
-    gpr_free(host);
-    gpr_free(port);
-  }
-}
-
-void (*grpc_resolve_address)(
-    const char* name, const char* default_port,
-    grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    grpc_resolved_addresses** addrs) = resolve_address_impl;
-
-#endif /* GRPC_UV */

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

@@ -1,175 +0,0 @@
-/*
- *
- * Copyright 2016 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 "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/iomgr_uv.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
-#include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/iomgr/tcp_uv.h"
-#include "src/core/lib/iomgr/timer.h"
-
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
-typedef struct grpc_uv_tcp_connect {
-  uv_connect_t connect_req;
-  grpc_timer alarm;
-  grpc_closure on_alarm;
-  uv_tcp_t* tcp_handle;
-  grpc_closure* closure;
-  grpc_endpoint** endpoint;
-  int refs;
-  char* addr_name;
-  grpc_resource_quota* resource_quota;
-} grpc_uv_tcp_connect;
-
-static void uv_tcp_connect_cleanup(grpc_uv_tcp_connect* connect) {
-  grpc_resource_quota_unref_internal(connect->resource_quota);
-  gpr_free(connect->addr_name);
-  gpr_free(connect);
-}
-
-static void tcp_close_callback(uv_handle_t* handle) { gpr_free(handle); }
-
-static void uv_tc_on_alarm(void* acp, grpc_error* error) {
-  int done;
-  grpc_uv_tcp_connect* connect = (grpc_uv_tcp_connect*)acp;
-  if (grpc_tcp_trace.enabled()) {
-    const char* str = grpc_error_string(error);
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            connect->addr_name, str);
-  }
-  if (error == GRPC_ERROR_NONE) {
-    /* error == NONE implies that the timer ran out, and wasn't cancelled. If
-       it was cancelled, then the handler that cancelled it also should close
-       the handle, if applicable */
-    uv_close((uv_handle_t*)connect->tcp_handle, tcp_close_callback);
-  }
-  done = (--connect->refs == 0);
-  if (done) {
-    uv_tcp_connect_cleanup(connect);
-  }
-}
-
-static void uv_tc_on_connect(uv_connect_t* req, int status) {
-  grpc_uv_tcp_connect* connect = (grpc_uv_tcp_connect*)req->data;
-  grpc_core::ExecCtx exec_ctx;
-  grpc_error* error = GRPC_ERROR_NONE;
-  int done;
-  grpc_closure* closure = connect->closure;
-  grpc_timer_cancel(&connect->alarm);
-  if (status == 0) {
-    *connect->endpoint = grpc_tcp_create(
-        connect->tcp_handle, connect->resource_quota, connect->addr_name);
-  } else {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Failed to connect to remote host");
-    error = grpc_error_set_int(error, GRPC_ERROR_INT_ERRNO, -status);
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                           grpc_slice_from_static_string(uv_strerror(status)));
-    if (status == UV_ECANCELED) {
-      error =
-          grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                             grpc_slice_from_static_string("Timeout occurred"));
-      // This should only happen if the handle is already closed
-    } else {
-      error = grpc_error_set_str(
-          error, GRPC_ERROR_STR_OS_ERROR,
-          grpc_slice_from_static_string(uv_strerror(status)));
-      uv_close((uv_handle_t*)connect->tcp_handle, tcp_close_callback);
-    }
-  }
-  done = (--connect->refs == 0);
-  if (done) {
-    grpc_core::ExecCtx::Get()->Flush();
-    uv_tcp_connect_cleanup(connect);
-  }
-  GRPC_CLOSURE_SCHED(closure, error);
-}
-
-static void tcp_client_connect_impl(grpc_closure* closure, grpc_endpoint** ep,
-                                    grpc_pollset_set* interested_parties,
-                                    const grpc_channel_args* channel_args,
-                                    const grpc_resolved_address* resolved_addr,
-                                    grpc_millis deadline) {
-  grpc_uv_tcp_connect* connect;
-  grpc_resource_quota* resource_quota = grpc_resource_quota_create(NULL);
-  (void)channel_args;
-  (void)interested_parties;
-
-  GRPC_UV_ASSERT_SAME_THREAD();
-
-  if (channel_args != NULL) {
-    for (size_t i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
-        grpc_resource_quota_unref_internal(resource_quota);
-        resource_quota = grpc_resource_quota_ref_internal(
-            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
-      }
-    }
-  }
-
-  connect = (grpc_uv_tcp_connect*)gpr_zalloc(sizeof(grpc_uv_tcp_connect));
-  connect->closure = closure;
-  connect->endpoint = ep;
-  connect->tcp_handle = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
-  connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
-  connect->resource_quota = resource_quota;
-  uv_tcp_init(uv_default_loop(), connect->tcp_handle);
-  connect->connect_req.data = connect;
-  connect->refs = 2;  // One for the connect operation, one for the timer.
-
-  if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %s: asynchronously connecting",
-            connect->addr_name);
-  }
-
-  // TODO(murgatroid99): figure out what the return value here means
-  uv_tcp_connect(&connect->connect_req, connect->tcp_handle,
-                 (const struct sockaddr*)resolved_addr->addr, uv_tc_on_connect);
-  GRPC_CLOSURE_INIT(&connect->on_alarm, uv_tc_on_alarm, connect,
-                    grpc_schedule_on_exec_ctx);
-  grpc_timer_init(&connect->alarm, deadline, &connect->on_alarm);
-}
-
-// overridden by api_fuzzer.c
-void (*grpc_tcp_client_connect_impl)(
-    grpc_closure* closure, grpc_endpoint** ep,
-    grpc_pollset_set* interested_parties, const grpc_channel_args* channel_args,
-    const grpc_resolved_address* addr,
-    grpc_millis deadline) = tcp_client_connect_impl;
-
-void grpc_tcp_client_connect(grpc_closure* closure, grpc_endpoint** ep,
-                             grpc_pollset_set* interested_parties,
-                             const grpc_channel_args* channel_args,
-                             const grpc_resolved_address* addr,
-                             grpc_millis deadline) {
-  grpc_tcp_client_connect_impl(closure, ep, interested_parties, channel_args,
-                               addr, deadline);
-}
-
-#endif /* GRPC_UV */