Exemplo n.º 1
0
GPR_EXPORT intptr_t GPR_CALLTYPE grpcsharp_batch_context_recv_message_length(
    const grpcsharp_batch_context *ctx) {
  if (!ctx->recv_message) {
    return -1;
  }
  return (intptr_t)grpc_byte_buffer_length(ctx->recv_message);
}
Exemplo n.º 2
0
static PyObject *pygrpc_read_event_args(grpc_event *c_event) {
  if (c_event->data.read == NULL) {
    return PyTuple_Pack(7, read_event_kind, (PyObject *)c_event->tag,
                        Py_None, Py_None, Py_None, Py_None, Py_None);
  } else {
    size_t length;
    size_t offset;
    grpc_byte_buffer_reader *reader;
    gpr_slice slice;
    char *c_bytes;
    PyObject *bytes;
    PyObject *event_args;

    length = grpc_byte_buffer_length(c_event->data.read);
    reader = grpc_byte_buffer_reader_create(c_event->data.read);
    c_bytes = gpr_malloc(length);
    offset = 0;
    while (grpc_byte_buffer_reader_next(reader, &slice)) {
      memcpy(c_bytes + offset, GPR_SLICE_START_PTR(slice),
             GPR_SLICE_LENGTH(slice));
      offset += GPR_SLICE_LENGTH(slice);
    }
    grpc_byte_buffer_reader_destroy(reader);
    bytes = PyBytes_FromStringAndSize(c_bytes, length);
    gpr_free(c_bytes);
    if (bytes == NULL) {
      return NULL;
    }
    event_args = PyTuple_Pack(7, read_event_kind, (PyObject *)c_event->tag,
                              Py_None, Py_None, Py_None, bytes, Py_None);
    Py_DECREF(bytes);
    return event_args;
  }
}
Exemplo n.º 3
0
GPR_EXPORT intptr_t GPR_CALLTYPE grpcsharp_batch_context_recv_message_length(
    const grpcsharp_batch_context *ctx) {
  grpc_byte_buffer_reader reader;
  if (!ctx->recv_message) {
    return -1;
  }

  GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, ctx->recv_message));
  intptr_t result = (intptr_t)grpc_byte_buffer_length(reader.buffer_out);
  grpc_byte_buffer_reader_destroy(&reader);

  return result;
}
Exemplo n.º 4
0
void byte_buffer_to_string(grpc_byte_buffer *buffer, char **out_string,
                           size_t *out_length) {
  size_t length = grpc_byte_buffer_length(buffer);
  char *string = ecalloc(length + 1, sizeof(char));
  size_t offset = 0;
  grpc_byte_buffer_reader *reader = grpc_byte_buffer_reader_create(buffer);
  gpr_slice next;
  while (grpc_byte_buffer_reader_next(reader, &next) != 0) {
    memcpy(string + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
    offset += GPR_SLICE_LENGTH(next);
  }
  *out_string = string;
  *out_length = length;
}
Exemplo n.º 5
0
grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader *reader) {
  grpc_slice in_slice;
  size_t bytes_read = 0;
  const size_t input_size = grpc_byte_buffer_length(reader->buffer_out);
  grpc_slice out_slice = grpc_slice_malloc(input_size);
  uint8_t *const outbuf = GRPC_SLICE_START_PTR(out_slice); /* just an alias */

  while (grpc_byte_buffer_reader_next(reader, &in_slice) != 0) {
    const size_t slice_length = GRPC_SLICE_LENGTH(in_slice);
    memcpy(&(outbuf[bytes_read]), GRPC_SLICE_START_PTR(in_slice), slice_length);
    bytes_read += slice_length;
    grpc_slice_unref(in_slice);
    GPR_ASSERT(bytes_read <= input_size);
  }
  return out_slice;
}
Exemplo n.º 6
0
VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
  size_t length = 0;
  char *string = NULL;
  size_t offset = 0;
  grpc_byte_buffer_reader reader;
  gpr_slice next;
  if (buffer == NULL) {
    return Qnil;

  }
  length = grpc_byte_buffer_length(buffer);
  string = xmalloc(length + 1);
  grpc_byte_buffer_reader_init(&reader, buffer);
  while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
    memcpy(string + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
    offset += GPR_SLICE_LENGTH(next);
  }
  return rb_str_new(string, length);
}
Exemplo n.º 7
0
VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
  VALUE rb_string;
  grpc_byte_buffer_reader reader;
  grpc_slice next;
  if (buffer == NULL) {
    return Qnil;
  }
  rb_string = rb_str_buf_new(grpc_byte_buffer_length(buffer));
  if (!grpc_byte_buffer_reader_init(&reader, buffer)) {
    rb_raise(rb_eRuntimeError, "Error initializing byte buffer reader.");
    return Qnil;
  }
  while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
    rb_str_cat(rb_string, (const char *) GRPC_SLICE_START_PTR(next),
               GRPC_SLICE_LENGTH(next));
    grpc_slice_unref(next);
  }
  grpc_byte_buffer_reader_destroy(&reader);
  return rb_string;
}
Exemplo n.º 8
0
static int fill_send_ops(grpc_call *call, grpc_transport_op *op) {
  grpc_ioreq_data data;
  grpc_metadata_batch mdb;
  size_t i;
  char status_str[GPR_LTOA_MIN_BUFSIZE];
  GPR_ASSERT(op->send_ops == NULL);

  switch (call->write_state) {
    case WRITE_STATE_INITIAL:
      if (!is_op_live(call, GRPC_IOREQ_SEND_INITIAL_METADATA)) {
        break;
      }
      data = call->request_data[GRPC_IOREQ_SEND_INITIAL_METADATA];
      mdb.list = chain_metadata_from_app(call, data.send_metadata.count,
                                         data.send_metadata.metadata);
      mdb.garbage.head = mdb.garbage.tail = NULL;
      mdb.deadline = call->send_deadline;
      for (i = 0; i < call->send_initial_metadata_count; i++) {
        grpc_metadata_batch_link_head(&mdb, &call->send_initial_metadata[i]);
      }
      grpc_sopb_add_metadata(&call->send_ops, mdb);
      op->send_ops = &call->send_ops;
      op->bind_pollset = grpc_cq_pollset(call->cq);
      call->last_send_contains |= 1 << GRPC_IOREQ_SEND_INITIAL_METADATA;
      call->write_state = WRITE_STATE_STARTED;
      call->send_initial_metadata_count = 0;
    /* fall through intended */
    case WRITE_STATE_STARTED:
      if (is_op_live(call, GRPC_IOREQ_SEND_MESSAGE)) {
        data = call->request_data[GRPC_IOREQ_SEND_MESSAGE];
        grpc_sopb_add_begin_message(
            &call->send_ops, grpc_byte_buffer_length(data.send_message), 0);
        copy_byte_buffer_to_stream_ops(data.send_message, &call->send_ops);
        op->send_ops = &call->send_ops;
        call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE;
      }
      if (is_op_live(call, GRPC_IOREQ_SEND_CLOSE)) {
        op->is_last_send = 1;
        op->send_ops = &call->send_ops;
        call->last_send_contains |= 1 << GRPC_IOREQ_SEND_CLOSE;
        call->write_state = WRITE_STATE_WRITE_CLOSED;
        if (!call->is_client) {
          /* send trailing metadata */
          data = call->request_data[GRPC_IOREQ_SEND_TRAILING_METADATA];
          mdb.list = chain_metadata_from_app(call, data.send_metadata.count,
                                             data.send_metadata.metadata);
          mdb.garbage.head = mdb.garbage.tail = NULL;
          mdb.deadline = gpr_inf_future;
          /* send status */
          /* TODO(ctiller): cache common status values */
          data = call->request_data[GRPC_IOREQ_SEND_STATUS];
          gpr_ltoa(data.send_status.code, status_str);
          grpc_metadata_batch_add_tail(
              &mdb, &call->status_link,
              grpc_mdelem_from_metadata_strings(
                  call->metadata_context,
                  grpc_mdstr_ref(grpc_channel_get_status_string(call->channel)),
                  grpc_mdstr_from_string(call->metadata_context, status_str)));
          if (data.send_status.details) {
            grpc_metadata_batch_add_tail(
                &mdb, &call->details_link,
                grpc_mdelem_from_metadata_strings(
                    call->metadata_context,
                    grpc_mdstr_ref(
                        grpc_channel_get_message_string(call->channel)),
                    grpc_mdstr_from_string(call->metadata_context,
                                           data.send_status.details)));
          }
          grpc_sopb_add_metadata(&call->send_ops, mdb);
        }
      }
      break;
    case WRITE_STATE_WRITE_CLOSED:
      break;
  }
  if (op->send_ops) {
    op->on_done_send = call_on_done_send;
    op->send_user_data = call;
  }
  return op->send_ops != NULL;
}