自学教程：C++ GRPC_API_TRACE函数代码示例

void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel,                                 const char *reason) {  gpr_log(GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel,          channel->refs.count, channel->refs.count - 1, reason);#elsevoid grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,                                 grpc_channel *channel) {#endif  if (gpr_unref(&channel->refs)) {    destroy_channel(exec_ctx, channel);  }}void grpc_channel_destroy(grpc_channel *channel) {  grpc_transport_op op;  grpc_channel_element *elem;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  GRPC_API_TRACE("grpc_channel_destroy(channel=%p)", 1, (channel));  memset(&op, 0, sizeof(op));  op.disconnect = 1;  elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);  elem->filter->start_transport_op(&exec_ctx, elem, &op);  GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, channel, "channel");  grpc_exec_ctx_finish(&exec_ctx);}

grpc_auth_property_iterator grpc_auth_context_peer_identity(    const grpc_auth_context *ctx) {  GRPC_API_TRACE("grpc_auth_context_peer_identity(ctx=%p)", 1, (ctx));  if (ctx == NULL) return empty_iterator;  return grpc_auth_context_find_properties_by_name(      ctx, ctx->peer_identity_property_name);}

grpc_call_error grpc_server_request_call(    grpc_server *server, grpc_call **call, grpc_call_details *details,    grpc_metadata_array *initial_metadata,    grpc_completion_queue *cq_bound_to_call,    grpc_completion_queue *cq_for_notification, void *tag) {  grpc_call_error error;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  requested_call *rc = gpr_malloc(sizeof(*rc));  GRPC_API_TRACE(      "grpc_server_request_call("      "server=%p, call=%p, details=%p, initial_metadata=%p, "      "cq_bound_to_call=%p, cq_for_notification=%p, tag=%p)",      7, (server, call, details, initial_metadata, cq_bound_to_call,          cq_for_notification, tag));  if (!grpc_cq_is_server_cq(cq_for_notification)) {    gpr_free(rc);    error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;    goto done;  }  grpc_cq_begin_op(cq_for_notification, tag);  details->reserved = NULL;  rc->type = BATCH_CALL;  rc->server = server;  rc->tag = tag;  rc->cq_bound_to_call = cq_bound_to_call;  rc->cq_for_notification = cq_for_notification;  rc->call = call;  rc->data.batch.details = details;  rc->initial_metadata = initial_metadata;  error = queue_call_request(&exec_ctx, server, rc);done:  grpc_exec_ctx_finish(&exec_ctx);  return error;}

void grpc_call_details_destroy(grpc_call_details* cd) {  GRPC_API_TRACE("grpc_call_details_destroy(cd=%p)", 1, (cd));  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  grpc_slice_unref_internal(&exec_ctx, cd->method);  grpc_slice_unref_internal(&exec_ctx, cd->host);  grpc_exec_ctx_finish(&exec_ctx);}

grpc_channel *grpc_insecure_channel_create_from_fd(    const char *target, int fd, const grpc_channel_args *args) {  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  GRPC_API_TRACE("grpc_insecure_channel_create(target=%p, fd=%d, args=%p)", 3,                 (target, fd, args));  grpc_arg default_authority_arg;  default_authority_arg.type = GRPC_ARG_STRING;  default_authority_arg.key = GRPC_ARG_DEFAULT_AUTHORITY;  default_authority_arg.value.string = "test.authority";  grpc_channel_args *final_args =      grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);  int flags = fcntl(fd, F_GETFL, 0);  GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);  grpc_endpoint *client = grpc_tcp_client_create_from_fd(      &exec_ctx, grpc_fd_create(fd, "client"), args, "fd-client");  grpc_transport *transport =      grpc_create_chttp2_transport(&exec_ctx, final_args, client, 1);  GPR_ASSERT(transport);  grpc_channel *channel = grpc_channel_create(      &exec_ctx, target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);  grpc_channel_args_destroy(final_args);  grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);  grpc_exec_ctx_finish(&exec_ctx);  return channel != NULL ? channel : grpc_lame_client_channel_create(                                         target, GRPC_STATUS_INTERNAL,                                         "Failed to create client channel");}

void grpc_server_start(grpc_server *server) {  listener *l;  size_t i;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  GRPC_API_TRACE("grpc_server_start(server=%p)", 1, (server));  server->started = true;  size_t pollset_count = 0;  server->pollsets = gpr_malloc(sizeof(grpc_pollset *) * server->cq_count);  for (i = 0; i < server->cq_count; i++) {    if (!grpc_cq_is_non_listening_server_cq(server->cqs[i])) {      server->pollsets[pollset_count++] = grpc_cq_pollset(server->cqs[i]);    }  }  request_matcher_init(&server->unregistered_request_matcher,                       server->max_requested_calls, server);  for (registered_method *rm = server->registered_methods; rm; rm = rm->next) {    request_matcher_init(&rm->request_matcher, server->max_requested_calls,                         server);  }  for (l = server->listeners; l; l = l->next) {    l->start(&exec_ctx, server, l->arg, server->pollsets, pollset_count);  }  grpc_exec_ctx_finish(&exec_ctx);}

int grpc_compression_algorithm_parse(const char *name, size_t name_length,                                     grpc_compression_algorithm *algorithm) {  /* we use strncmp not only because it's safer (even though in this case it   * doesn't matter, given that we are comparing against string literals, but   * because this way we needn't have "name" nil-terminated (useful for slice   * data, for example) */  GRPC_API_TRACE(      "grpc_compression_algorithm_parse("      "name=%*.*s, name_length=%lu, algorithm=%p)",      5, ((int)name_length, (int)name_length, name, (unsigned long)name_length,          algorithm));  if (name_length == 0) {    return 0;  }  if (strncmp(name, "identity", name_length) == 0) {    *algorithm = GRPC_COMPRESS_NONE;  } else if (strncmp(name, "gzip", name_length) == 0) {    *algorithm = GRPC_COMPRESS_GZIP;  } else if (strncmp(name, "deflate", name_length) == 0) {    *algorithm = GRPC_COMPRESS_DEFLATE;  } else {    return 0;  }  return 1;}

void *grpc_server_register_method(grpc_server *server, const char *method,                                  const char *host) {  registered_method *m;  GRPC_API_TRACE("grpc_server_register_method(server=%p, method=%s, host=%s)",                 3, (server, method, host));  if (!method) {    gpr_log(GPR_ERROR,            "grpc_server_register_method method string cannot be NULL");    return NULL;  }  for (m = server->registered_methods; m; m = m->next) {    if (streq(m->method, method) && streq(m->host, host)) {      gpr_log(GPR_ERROR, "duplicate registration for %[email
C++ GRPC_ERROR_CREATE函数代码示例
C++ GROUP_FILTER_SIZE函数代码示例