C++ (Cpp) grpc_iomgr_register_objectの例

コード例 #1

ファイル: httpcli.c プロジェクト: sihai/grpc

void grpc_httpcli_post(grpc_httpcli_context *context, grpc_pollset *pollset,
                       const grpc_httpcli_request *request,
                       const char *body_bytes, size_t body_size,
                       gpr_timespec deadline,
                       grpc_httpcli_response_cb on_response, void *user_data) {
  internal_request *req;
  char *name;
  if (g_post_override && g_post_override(request, body_bytes, body_size,
                                         deadline, on_response, user_data)) {
    return;
  }
  req = gpr_malloc(sizeof(internal_request));
  memset(req, 0, sizeof(*req));
  req->request_text =
      grpc_httpcli_format_post_request(request, body_bytes, body_size);
  grpc_httpcli_parser_init(&req->parser);
  req->on_response = on_response;
  req->user_data = user_data;
  req->deadline = deadline;
  req->use_ssl = request->use_ssl;
  req->context = context;
  req->pollset = pollset;
  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->path);
  grpc_iomgr_register_object(&req->iomgr_obj, name);
  gpr_free(name);
  if (req->use_ssl) {
    req->host = gpr_strdup(request->host);
  }

  grpc_pollset_set_add_pollset(&req->context->pollset_set, req->pollset);
  grpc_resolve_address(request->host, req->use_ssl ? "https" : "http",
                       on_resolved, req);
}

コード例 #2

ファイル: httpcli.c プロジェクト: AlexTalks/bazel

static void internal_request_begin(
    grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
    grpc_pollset *pollset, const grpc_httpcli_request *request,
    gpr_timespec deadline, grpc_httpcli_response_cb on_response,
    void *user_data, const char *name, gpr_slice request_text) {
  internal_request *req = gpr_malloc(sizeof(internal_request));
  memset(req, 0, sizeof(*req));
  req->request_text = request_text;
  grpc_httpcli_parser_init(&req->parser);
  req->on_response = on_response;
  req->user_data = user_data;
  req->deadline = deadline;
  req->handshaker =
      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext;
  req->context = context;
  req->pollset = pollset;
  grpc_closure_init(&req->on_read, on_read, req);
  grpc_closure_init(&req->done_write, done_write, req);
  gpr_slice_buffer_init(&req->incoming);
  gpr_slice_buffer_init(&req->outgoing);
  grpc_iomgr_register_object(&req->iomgr_obj, name);
  req->host = gpr_strdup(request->host);
  req->ssl_host_override = gpr_strdup(request->ssl_host_override);

  grpc_pollset_set_add_pollset(exec_ctx, &req->context->pollset_set,
                               req->pollset);
  grpc_resolve_address(request->host, req->handshaker->default_port,
                       on_resolved, req);
}

コード例 #3

ファイル: fd_posix.c プロジェクト: ruinanchen/grpc

grpc_fd *grpc_fd_create(int fd, const char *name) {
  grpc_fd *r = alloc_fd(fd);
  grpc_iomgr_register_object(&r->iomgr_object, name);
#ifdef GRPC_FD_REF_COUNT_DEBUG
  gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, r, name);
#endif
  return r;
}

コード例 #4

ファイル: socket_windows.c プロジェクト: Indifer/grpc

grpc_winsocket *grpc_winsocket_create(SOCKET socket, const char *name) {
  char *final_name;
  grpc_winsocket *r = gpr_malloc(sizeof(grpc_winsocket));
  memset(r, 0, sizeof(grpc_winsocket));
  r->socket = socket;
  gpr_mu_init(&r->state_mu);
  gpr_asprintf(&final_name, "%s:socket=0x%p", name, r);
  grpc_iomgr_register_object(&r->iomgr_object, final_name);
  gpr_free(final_name);
  grpc_iocp_add_socket(r);
  return r;
}

コード例 #5

ファイル: resolve_address_windows.c プロジェクト: bjori/grpc

void grpc_resolve_address(const char *name, const char *default_port,
                          grpc_resolve_cb cb, void *arg) {
  request *r = gpr_malloc(sizeof(request));
  gpr_thd_id id;
  char *label;
  gpr_asprintf(&label, "resolve:%s", name);
  grpc_iomgr_register_object(&r->iomgr_object, label);
  gpr_free(label);
  r->name = gpr_strdup(name);
  r->default_port = gpr_strdup(default_port);
  r->cb = cb;
  r->arg = arg;
  gpr_thd_new(&id, do_request, r, NULL);
}

コード例 #6

ファイル: ev_epollex_linux.c プロジェクト: aaronjheng/grpc

static grpc_fd *fd_create(int fd, const char *name) {
  grpc_fd *new_fd = NULL;

  gpr_mu_lock(&fd_freelist_mu);
  if (fd_freelist != NULL) {
    new_fd = fd_freelist;
    fd_freelist = fd_freelist->freelist_next;
  }
  gpr_mu_unlock(&fd_freelist_mu);

  if (new_fd == NULL) {
    new_fd = gpr_malloc(sizeof(grpc_fd));
  }

  pollable_init(&new_fd->pollable, PO_FD);

  gpr_atm_rel_store(&new_fd->refst, (gpr_atm)1);
  new_fd->fd = fd;
  gpr_mu_init(&new_fd->orphaned_mu);
  new_fd->orphaned = false;
  grpc_lfev_init(&new_fd->read_closure);
  grpc_lfev_init(&new_fd->write_closure);
  gpr_atm_no_barrier_store(&new_fd->read_notifier_pollset, (gpr_atm)NULL);

  new_fd->freelist_next = NULL;
  new_fd->on_done_closure = NULL;

  char *fd_name;
  gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name);
#ifndef NDEBUG
  if (GRPC_TRACER_ON(grpc_trace_fd_refcount)) {
    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name);
  }
#endif
  gpr_free(fd_name);
  return new_fd;
}

コード例 #7

ファイル: fd_posix.c プロジェクト: Infixz/grpc

grpc_fd *grpc_fd_create(int fd, const char *name) {
  grpc_fd *r = alloc_fd(fd);
  grpc_iomgr_register_object(&r->iomgr_object, name);
  grpc_pollset_add_fd(grpc_backup_pollset(), r);
  return r;
}

コード例 #8

ファイル: fd_posix.c プロジェクト: sihai/grpc

grpc_fd *grpc_fd_create(int fd, const char *name) {
  grpc_fd *r = alloc_fd(fd);
  grpc_iomgr_register_object(&r->iomgr_object, name);
  return r;
}