Extend clang-format to C#, Node, Ruby
diff --git a/src/csharp/ext/grpc_csharp_ext.c b/src/csharp/ext/grpc_csharp_ext.c
index 27de7bc..88adef0 100644
--- a/src/csharp/ext/grpc_csharp_ext.c
+++ b/src/csharp/ext/grpc_csharp_ext.c
@@ -34,14 +34,14 @@
#include "src/core/lib/support/string.h"
#include <grpc/byte_buffer_reader.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/slice.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/thd.h>
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
+#include <grpc/slice.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/thd.h>
#include <string.h>
@@ -84,7 +84,8 @@
int recv_close_on_server_cancelled;
} grpcsharp_batch_context;
-GPR_EXPORT grpcsharp_batch_context *GPR_CALLTYPE grpcsharp_batch_context_create() {
+GPR_EXPORT grpcsharp_batch_context *GPR_CALLTYPE
+grpcsharp_batch_context_create() {
grpcsharp_batch_context *ctx = gpr_malloc(sizeof(grpcsharp_batch_context));
memset(ctx, 0, sizeof(grpcsharp_batch_context));
return ctx;
@@ -96,8 +97,10 @@
grpc_metadata_array request_metadata;
} grpcsharp_request_call_context;
-GPR_EXPORT grpcsharp_request_call_context *GPR_CALLTYPE grpcsharp_request_call_context_create() {
- grpcsharp_request_call_context *ctx = gpr_malloc(sizeof(grpcsharp_request_call_context));
+GPR_EXPORT grpcsharp_request_call_context *GPR_CALLTYPE
+grpcsharp_request_call_context_create() {
+ grpcsharp_request_call_context *ctx =
+ gpr_malloc(sizeof(grpcsharp_request_call_context));
memset(ctx, 0, sizeof(grpcsharp_request_call_context));
return ctx;
}
@@ -175,15 +178,15 @@
return (intptr_t)array->count;
}
-GPR_EXPORT const char *GPR_CALLTYPE
-grpcsharp_metadata_array_get_key(grpc_metadata_array *array, size_t index, size_t *key_length) {
+GPR_EXPORT const char *GPR_CALLTYPE grpcsharp_metadata_array_get_key(
+ grpc_metadata_array *array, size_t index, size_t *key_length) {
GPR_ASSERT(index < array->count);
*key_length = GRPC_SLICE_LENGTH(array->metadata[index].key);
return (char *)GRPC_SLICE_START_PTR(array->metadata[index].key);
}
-GPR_EXPORT const char *GPR_CALLTYPE
-grpcsharp_metadata_array_get_value(grpc_metadata_array *array, size_t index, size_t *value_length) {
+GPR_EXPORT const char *GPR_CALLTYPE grpcsharp_metadata_array_get_value(
+ grpc_metadata_array *array, size_t index, size_t *value_length) {
GPR_ASSERT(index < array->count);
*value_length = GRPC_SLICE_LENGTH(array->metadata[index].value);
return (char *)GRPC_SLICE_START_PTR(array->metadata[index].value);
@@ -208,7 +211,8 @@
src->metadata = NULL;
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_batch_context_destroy(grpcsharp_batch_context *ctx) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_batch_context_destroy(grpcsharp_batch_context *ctx) {
if (!ctx) {
return;
}
@@ -231,7 +235,8 @@
gpr_free(ctx);
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_request_call_context_destroy(grpcsharp_request_call_context *ctx) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_request_call_context_destroy(grpcsharp_request_call_context *ctx) {
if (!ctx) {
return;
}
@@ -240,8 +245,7 @@
to take its ownership. */
grpc_call_details_destroy(&(ctx->call_details));
- grpcsharp_metadata_array_destroy_metadata_only(
- &(ctx->request_metadata));
+ grpcsharp_metadata_array_destroy_metadata_only(&(ctx->request_metadata));
gpr_free(ctx);
}
@@ -299,8 +303,10 @@
GPR_EXPORT const char *GPR_CALLTYPE
grpcsharp_batch_context_recv_status_on_client_details(
const grpcsharp_batch_context *ctx, size_t *details_length) {
- *details_length = GRPC_SLICE_LENGTH(ctx->recv_status_on_client.status_details);
- return (char *)GRPC_SLICE_START_PTR(ctx->recv_status_on_client.status_details);
+ *details_length =
+ GRPC_SLICE_LENGTH(ctx->recv_status_on_client.status_details);
+ return (char *)GRPC_SLICE_START_PTR(
+ ctx->recv_status_on_client.status_details);
}
GPR_EXPORT const grpc_metadata_array *GPR_CALLTYPE
@@ -309,13 +315,12 @@
return &(ctx->recv_status_on_client.trailing_metadata);
}
-GPR_EXPORT grpc_call *GPR_CALLTYPE grpcsharp_request_call_context_call(
- const grpcsharp_request_call_context *ctx) {
+GPR_EXPORT grpc_call *GPR_CALLTYPE
+grpcsharp_request_call_context_call(const grpcsharp_request_call_context *ctx) {
return ctx->call;
}
-GPR_EXPORT const char *GPR_CALLTYPE
-grpcsharp_request_call_context_method(
+GPR_EXPORT const char *GPR_CALLTYPE grpcsharp_request_call_context_method(
const grpcsharp_request_call_context *ctx, size_t *method_length) {
*method_length = GRPC_SLICE_LENGTH(ctx->call_details.method);
return (char *)GRPC_SLICE_START_PTR(ctx->call_details.method);
@@ -327,8 +332,7 @@
return (char *)GRPC_SLICE_START_PTR(ctx->call_details.host);
}
-GPR_EXPORT gpr_timespec GPR_CALLTYPE
-grpcsharp_request_call_context_deadline(
+GPR_EXPORT gpr_timespec GPR_CALLTYPE grpcsharp_request_call_context_deadline(
const grpcsharp_request_call_context *ctx) {
return ctx->call_details.deadline;
}
@@ -342,7 +346,7 @@
GPR_EXPORT int32_t GPR_CALLTYPE
grpcsharp_batch_context_recv_close_on_server_cancelled(
const grpcsharp_batch_context *ctx) {
- return (int32_t) ctx->recv_close_on_server_cancelled;
+ return (int32_t)ctx->recv_close_on_server_cancelled;
}
/* Init & shutdown */
@@ -389,7 +393,8 @@
GPR_EXPORT grpc_channel *GPR_CALLTYPE
-grpcsharp_insecure_channel_create(const char *target, const grpc_channel_args *args) {
+grpcsharp_insecure_channel_create(const char *target,
+ const grpc_channel_args *args) {
return grpc_insecure_channel_create(target, args, NULL);
}
@@ -397,12 +402,10 @@
grpc_channel_destroy(channel);
}
-GPR_EXPORT grpc_call *GPR_CALLTYPE
-grpcsharp_channel_create_call(grpc_channel *channel, grpc_call *parent_call,
- uint32_t propagation_mask,
- grpc_completion_queue *cq,
- const char *method, const char *host,
- gpr_timespec deadline) {
+GPR_EXPORT grpc_call *GPR_CALLTYPE grpcsharp_channel_create_call(
+ grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask,
+ grpc_completion_queue *cq, const char *method, const char *host,
+ gpr_timespec deadline) {
grpc_slice method_slice = grpc_slice_from_copied_string(method);
grpc_slice *host_slice_ptr = NULL;
grpc_slice host_slice;
@@ -415,18 +418,21 @@
}
GPR_EXPORT grpc_connectivity_state GPR_CALLTYPE
-grpcsharp_channel_check_connectivity_state(grpc_channel *channel, int32_t try_to_connect) {
+grpcsharp_channel_check_connectivity_state(grpc_channel *channel,
+ int32_t try_to_connect) {
return grpc_channel_check_connectivity_state(channel, try_to_connect);
}
GPR_EXPORT void GPR_CALLTYPE grpcsharp_channel_watch_connectivity_state(
grpc_channel *channel, grpc_connectivity_state last_observed_state,
- gpr_timespec deadline, grpc_completion_queue *cq, grpcsharp_batch_context *ctx) {
- grpc_channel_watch_connectivity_state(channel, last_observed_state,
- deadline, cq, ctx);
+ gpr_timespec deadline, grpc_completion_queue *cq,
+ grpcsharp_batch_context *ctx) {
+ grpc_channel_watch_connectivity_state(channel, last_observed_state, deadline,
+ cq, ctx);
}
-GPR_EXPORT char *GPR_CALLTYPE grpcsharp_channel_get_target(grpc_channel *channel) {
+GPR_EXPORT char *GPR_CALLTYPE
+grpcsharp_channel_get_target(grpc_channel *channel) {
return grpc_channel_get_target(channel);
}
@@ -444,9 +450,8 @@
return args;
}
-GPR_EXPORT void GPR_CALLTYPE
-grpcsharp_channel_args_set_string(grpc_channel_args *args, size_t index,
- const char *key, const char *value) {
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_channel_args_set_string(
+ grpc_channel_args *args, size_t index, const char *key, const char *value) {
GPR_ASSERT(args);
GPR_ASSERT(index < args->num_args);
args->args[index].type = GRPC_ARG_STRING;
@@ -454,9 +459,8 @@
args->args[index].value.string = gpr_strdup(value);
}
-GPR_EXPORT void GPR_CALLTYPE
-grpcsharp_channel_args_set_integer(grpc_channel_args *args, size_t index,
- const char *key, int value) {
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_channel_args_set_integer(
+ grpc_channel_args *args, size_t index, const char *key, int value) {
GPR_ASSERT(args);
GPR_ASSERT(index < args->num_args);
args->args[index].type = GRPC_ARG_INTEGER;
@@ -485,15 +489,18 @@
return gpr_now(clock_type);
}
-GPR_EXPORT gpr_timespec GPR_CALLTYPE gprsharp_inf_future(gpr_clock_type clock_type) {
+GPR_EXPORT gpr_timespec GPR_CALLTYPE
+gprsharp_inf_future(gpr_clock_type clock_type) {
return gpr_inf_future(clock_type);
}
-GPR_EXPORT gpr_timespec GPR_CALLTYPE gprsharp_inf_past(gpr_clock_type clock_type) {
+GPR_EXPORT gpr_timespec GPR_CALLTYPE
+gprsharp_inf_past(gpr_clock_type clock_type) {
return gpr_inf_past(clock_type);
}
-GPR_EXPORT gpr_timespec GPR_CALLTYPE gprsharp_convert_clock_type(gpr_timespec t, gpr_clock_type target_clock) {
+GPR_EXPORT gpr_timespec GPR_CALLTYPE
+gprsharp_convert_clock_type(gpr_timespec t, gpr_clock_type target_clock) {
return gpr_convert_clock_type(t, target_clock);
}
@@ -507,9 +514,8 @@
return grpc_call_cancel(call, NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_cancel_with_status(grpc_call *call, grpc_status_code status,
- const char *description) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_cancel_with_status(
+ grpc_call *call, grpc_status_code status, const char *description) {
return grpc_call_cancel_with_status(call, status, description, NULL);
}
@@ -517,18 +523,16 @@
return grpc_call_get_peer(call);
}
-GPR_EXPORT void GPR_CALLTYPE gprsharp_free(void *p) {
- gpr_free(p);
-}
+GPR_EXPORT void GPR_CALLTYPE gprsharp_free(void *p) { gpr_free(p); }
GPR_EXPORT void GPR_CALLTYPE grpcsharp_call_destroy(grpc_call *call) {
grpc_call_destroy(call);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_start_unary(grpc_call *call, grpcsharp_batch_context *ctx,
- const char *send_buffer, size_t send_buffer_len, uint32_t write_flags,
- grpc_metadata_array *initial_metadata, uint32_t initial_metadata_flags) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_start_unary(
+ grpc_call *call, grpcsharp_batch_context *ctx, const char *send_buffer,
+ size_t send_buffer_len, uint32_t write_flags,
+ grpc_metadata_array *initial_metadata, uint32_t initial_metadata_flags) {
/* TODO: don't use magic number */
grpc_op ops[6];
memset(ops, 0, sizeof(ops));
@@ -576,11 +580,9 @@
NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_start_client_streaming(grpc_call *call,
- grpcsharp_batch_context *ctx,
- grpc_metadata_array *initial_metadata,
- uint32_t initial_metadata_flags) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_start_client_streaming(
+ grpc_call *call, grpcsharp_batch_context *ctx,
+ grpc_metadata_array *initial_metadata, uint32_t initial_metadata_flags) {
/* TODO: don't use magic number */
grpc_op ops[4];
memset(ops, 0, sizeof(ops));
@@ -658,11 +660,9 @@
NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_start_duplex_streaming(grpc_call *call,
- grpcsharp_batch_context *ctx,
- grpc_metadata_array *initial_metadata,
- uint32_t initial_metadata_flags) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_start_duplex_streaming(
+ grpc_call *call, grpcsharp_batch_context *ctx,
+ grpc_metadata_array *initial_metadata, uint32_t initial_metadata_flags) {
/* TODO: don't use magic number */
grpc_op ops[2];
memset(ops, 0, sizeof(ops));
@@ -690,7 +690,7 @@
}
GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_recv_initial_metadata(
- grpc_call *call, grpcsharp_batch_context *ctx) {
+ grpc_call *call, grpcsharp_batch_context *ctx) {
/* TODO: don't use magic number */
grpc_op ops[1];
ops[0].op = GRPC_OP_RECV_INITIAL_METADATA;
@@ -700,14 +700,13 @@
ops[0].reserved = NULL;
return grpc_call_start_batch(call, ops, sizeof(ops) / sizeof(ops[0]), ctx,
- NULL);
+ NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_send_message(grpc_call *call, grpcsharp_batch_context *ctx,
- const char *send_buffer, size_t send_buffer_len,
- uint32_t write_flags,
- int32_t send_empty_initial_metadata) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_send_message(
+ grpc_call *call, grpcsharp_batch_context *ctx, const char *send_buffer,
+ size_t send_buffer_len, uint32_t write_flags,
+ int32_t send_empty_initial_metadata) {
/* TODO: don't use magic number */
grpc_op ops[2];
memset(ops, 0, sizeof(ops));
@@ -724,9 +723,8 @@
return grpc_call_start_batch(call, ops, nops, ctx, NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_send_close_from_client(grpc_call *call,
- grpcsharp_batch_context *ctx) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_send_close_from_client(
+ grpc_call *call, grpcsharp_batch_context *ctx) {
/* TODO: don't use magic number */
grpc_op ops[1];
ops[0].op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
@@ -740,14 +738,15 @@
GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_send_status_from_server(
grpc_call *call, grpcsharp_batch_context *ctx, grpc_status_code status_code,
const char *status_details, size_t status_details_len,
- grpc_metadata_array *trailing_metadata,
- int32_t send_empty_initial_metadata, const char* optional_send_buffer,
- size_t optional_send_buffer_len, uint32_t write_flags) {
+ grpc_metadata_array *trailing_metadata, int32_t send_empty_initial_metadata,
+ const char *optional_send_buffer, size_t optional_send_buffer_len,
+ uint32_t write_flags) {
/* TODO: don't use magic number */
grpc_op ops[3];
memset(ops, 0, sizeof(ops));
size_t nops = 1;
- grpc_slice status_details_slice = grpc_slice_from_copied_buffer(status_details, status_details_len);
+ grpc_slice status_details_slice =
+ grpc_slice_from_copied_buffer(status_details, status_details_len);
ops[0].op = GRPC_OP_SEND_STATUS_FROM_SERVER;
ops[0].data.send_status_from_server.status = status_code;
ops[0].data.send_status_from_server.status_details = &status_details_slice;
@@ -761,8 +760,8 @@
ops[0].reserved = NULL;
if (optional_send_buffer) {
ops[nops].op = GRPC_OP_SEND_MESSAGE;
- ctx->send_message = string_to_byte_buffer(optional_send_buffer,
- optional_send_buffer_len);
+ ctx->send_message =
+ string_to_byte_buffer(optional_send_buffer, optional_send_buffer_len);
ops[nops].data.send_message.send_message = ctx->send_message;
ops[nops].flags = write_flags;
ops[nops].reserved = NULL;
@@ -803,10 +802,9 @@
NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE
-grpcsharp_call_send_initial_metadata(grpc_call *call,
- grpcsharp_batch_context *ctx,
- grpc_metadata_array *initial_metadata) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_send_initial_metadata(
+ grpc_call *call, grpcsharp_batch_context *ctx,
+ grpc_metadata_array *initial_metadata) {
/* TODO: don't use magic number */
grpc_op ops[1];
memset(ops, 0, sizeof(ops));
@@ -823,9 +821,8 @@
NULL);
}
-GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_set_credentials(
- grpc_call *call,
- grpc_call_credentials *creds) {
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_set_credentials(grpc_call *call, grpc_call_credentials *creds) {
return grpc_call_set_credentials(call, creds);
}
@@ -836,14 +833,13 @@
return grpc_server_create(args, NULL);
}
-GPR_EXPORT void GPR_CALLTYPE
-grpcsharp_server_register_completion_queue(grpc_server *server,
- grpc_completion_queue *cq) {
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_register_completion_queue(
+ grpc_server *server, grpc_completion_queue *cq) {
grpc_server_register_completion_queue(server, cq, NULL);
}
-GPR_EXPORT int32_t GPR_CALLTYPE
-grpcsharp_server_add_insecure_http2_port(grpc_server *server, const char *addr) {
+GPR_EXPORT int32_t GPR_CALLTYPE grpcsharp_server_add_insecure_http2_port(
+ grpc_server *server, const char *addr) {
return grpc_server_add_insecure_http2_port(server, addr);
}
@@ -851,14 +847,14 @@
grpc_server_start(server);
}
-GPR_EXPORT void GPR_CALLTYPE
-grpcsharp_server_shutdown_and_notify_callback(grpc_server *server,
- grpc_completion_queue *cq,
- grpcsharp_batch_context *ctx) {
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_shutdown_and_notify_callback(
+ grpc_server *server, grpc_completion_queue *cq,
+ grpcsharp_batch_context *ctx) {
grpc_server_shutdown_and_notify(server, cq, ctx);
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_cancel_all_calls(grpc_server *server) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_server_cancel_all_calls(grpc_server *server) {
grpc_server_cancel_all_calls(server);
}
@@ -869,9 +865,8 @@
GPR_EXPORT grpc_call_error GPR_CALLTYPE
grpcsharp_server_request_call(grpc_server *server, grpc_completion_queue *cq,
grpcsharp_request_call_context *ctx) {
- return grpc_server_request_call(
- server, &(ctx->call), &(ctx->call_details),
- &(ctx->request_metadata), cq, cq, ctx);
+ return grpc_server_request_call(server, &(ctx->call), &(ctx->call_details),
+ &(ctx->request_metadata), cq, cq, ctx);
}
/* Security */
@@ -888,8 +883,8 @@
return GRPC_SSL_ROOTS_OVERRIDE_OK;
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_override_default_ssl_roots(
- const char *pem_root_certs) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_override_default_ssl_roots(const char *pem_root_certs) {
/*
* This currently wastes ~300kB of memory by keeping a copy of roots
* in a static variable, but for desktop/server use, the overhead
@@ -916,20 +911,19 @@
}
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_channel_credentials_release(
- grpc_channel_credentials *creds) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_channel_credentials_release(grpc_channel_credentials *creds) {
grpc_channel_credentials_release(creds);
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_call_credentials_release(
- grpc_call_credentials *creds) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_call_credentials_release(grpc_call_credentials *creds) {
grpc_call_credentials_release(creds);
}
-GPR_EXPORT grpc_channel *GPR_CALLTYPE
-grpcsharp_secure_channel_create(grpc_channel_credentials *creds,
- const char *target,
- const grpc_channel_args *args) {
+GPR_EXPORT grpc_channel *GPR_CALLTYPE grpcsharp_secure_channel_create(
+ grpc_channel_credentials *creds, const char *target,
+ const grpc_channel_args *args) {
return grpc_secure_channel_create(creds, target, args, NULL);
}
@@ -962,36 +956,36 @@
return creds;
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_credentials_release(
- grpc_server_credentials *creds) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_server_credentials_release(grpc_server_credentials *creds) {
grpc_server_credentials_release(creds);
}
-GPR_EXPORT int32_t GPR_CALLTYPE
-grpcsharp_server_add_secure_http2_port(grpc_server *server, const char *addr,
- grpc_server_credentials *creds) {
+GPR_EXPORT int32_t GPR_CALLTYPE grpcsharp_server_add_secure_http2_port(
+ grpc_server *server, const char *addr, grpc_server_credentials *creds) {
return grpc_server_add_secure_http2_port(server, addr, creds);
}
-GPR_EXPORT grpc_channel_credentials *GPR_CALLTYPE grpcsharp_composite_channel_credentials_create(
- grpc_channel_credentials *channel_creds,
- grpc_call_credentials *call_creds) {
- return grpc_composite_channel_credentials_create(channel_creds, call_creds, NULL);
+GPR_EXPORT grpc_channel_credentials *GPR_CALLTYPE
+grpcsharp_composite_channel_credentials_create(
+ grpc_channel_credentials *channel_creds,
+ grpc_call_credentials *call_creds) {
+ return grpc_composite_channel_credentials_create(channel_creds, call_creds,
+ NULL);
}
-GPR_EXPORT grpc_call_credentials *GPR_CALLTYPE grpcsharp_composite_call_credentials_create(
- grpc_call_credentials *creds1,
- grpc_call_credentials *creds2) {
+GPR_EXPORT grpc_call_credentials *GPR_CALLTYPE
+grpcsharp_composite_call_credentials_create(grpc_call_credentials *creds1,
+ grpc_call_credentials *creds2) {
return grpc_composite_call_credentials_create(creds1, creds2, NULL);
}
-
/* Metadata credentials plugin */
GPR_EXPORT void GPR_CALLTYPE grpcsharp_metadata_credentials_notify_from_plugin(
- grpc_credentials_plugin_metadata_cb cb,
- void *user_data, grpc_metadata_array *metadata,
- grpc_status_code status, const char *error_details) {
+ grpc_credentials_plugin_metadata_cb cb, void *user_data,
+ grpc_metadata_array *metadata, grpc_status_code status,
+ const char *error_details) {
if (metadata) {
cb(user_data, metadata->metadata, metadata->count, status, error_details);
} else {
@@ -1000,16 +994,17 @@
}
typedef void(GPR_CALLTYPE *grpcsharp_metadata_interceptor_func)(
- void *state, const char *service_url, const char *method_name,
- grpc_credentials_plugin_metadata_cb cb,
- void *user_data, int32_t is_destroy);
+ void *state, const char *service_url, const char *method_name,
+ grpc_credentials_plugin_metadata_cb cb, void *user_data,
+ int32_t is_destroy);
static void grpcsharp_get_metadata_handler(
void *state, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb, void *user_data) {
grpcsharp_metadata_interceptor_func interceptor =
(grpcsharp_metadata_interceptor_func)(intptr_t)state;
- interceptor(state, context.service_url, context.method_name, cb, user_data, 0);
+ interceptor(state, context.service_url, context.method_name, cb, user_data,
+ 0);
}
static void grpcsharp_metadata_credentials_destroy_handler(void *state) {
@@ -1018,23 +1013,26 @@
interceptor(state, NULL, NULL, NULL, NULL, 1);
}
-GPR_EXPORT grpc_call_credentials *GPR_CALLTYPE grpcsharp_metadata_credentials_create_from_plugin(
- grpcsharp_metadata_interceptor_func metadata_interceptor) {
+GPR_EXPORT grpc_call_credentials *GPR_CALLTYPE
+grpcsharp_metadata_credentials_create_from_plugin(
+ grpcsharp_metadata_interceptor_func metadata_interceptor) {
grpc_metadata_credentials_plugin plugin;
plugin.get_metadata = grpcsharp_get_metadata_handler;
plugin.destroy = grpcsharp_metadata_credentials_destroy_handler;
- plugin.state = (void*)(intptr_t)metadata_interceptor;
+ plugin.state = (void *)(intptr_t)metadata_interceptor;
plugin.type = "";
return grpc_metadata_credentials_create_from_plugin(plugin, NULL);
}
/* Auth context */
-GPR_EXPORT grpc_auth_context *GPR_CALLTYPE grpcsharp_call_auth_context(grpc_call *call) {
+GPR_EXPORT grpc_auth_context *GPR_CALLTYPE
+grpcsharp_call_auth_context(grpc_call *call) {
return grpc_call_auth_context(call);
}
-GPR_EXPORT const char *GPR_CALLTYPE grpcsharp_auth_context_peer_identity_property_name(
+GPR_EXPORT const char *GPR_CALLTYPE
+grpcsharp_auth_context_peer_identity_property_name(
const grpc_auth_context *ctx) {
return grpc_auth_context_peer_identity_property_name(ctx);
}
@@ -1044,12 +1042,13 @@
return grpc_auth_context_property_iterator(ctx);
}
-GPR_EXPORT const grpc_auth_property *GPR_CALLTYPE grpcsharp_auth_property_iterator_next(
- grpc_auth_property_iterator *it) {
+GPR_EXPORT const grpc_auth_property *GPR_CALLTYPE
+grpcsharp_auth_property_iterator_next(grpc_auth_property_iterator *it) {
return grpc_auth_property_iterator_next(it);
}
-GPR_EXPORT void GPR_CALLTYPE grpcsharp_auth_context_release(grpc_auth_context *ctx) {
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_auth_context_release(grpc_auth_context *ctx) {
grpc_auth_context_release(ctx);
}
diff --git a/src/node/ext/byte_buffer.cc b/src/node/ext/byte_buffer.cc
index a99b96b..470c7ed 100644
--- a/src/node/ext/byte_buffer.cc
+++ b/src/node/ext/byte_buffer.cc
@@ -33,10 +33,10 @@
#include <string.h>
-#include <node.h>
#include <nan.h>
-#include "grpc/grpc.h"
+#include <node.h>
#include "grpc/byte_buffer_reader.h"
+#include "grpc/grpc.h"
#include "grpc/slice.h"
#include "byte_buffer.h"
diff --git a/src/node/ext/byte_buffer.h b/src/node/ext/byte_buffer.h
index e8c4ac9..6cb7a26 100644
--- a/src/node/ext/byte_buffer.h
+++ b/src/node/ext/byte_buffer.h
@@ -36,8 +36,8 @@
#include <string.h>
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
namespace grpc {
diff --git a/src/node/ext/call.cc b/src/node/ext/call.cc
index bd60775..0f192ac 100644
--- a/src/node/ext/call.cc
+++ b/src/node/ext/call.cc
@@ -31,23 +31,23 @@
*
*/
+#include <map>
#include <memory>
#include <vector>
-#include <map>
#include <node.h>
-#include "grpc/support/log.h"
-#include "grpc/grpc.h"
-#include "grpc/grpc_security.h"
-#include "grpc/support/alloc.h"
-#include "grpc/support/time.h"
#include "byte_buffer.h"
#include "call.h"
+#include "call_credentials.h"
#include "channel.h"
#include "completion_queue.h"
#include "completion_queue_async_worker.h"
-#include "call_credentials.h"
+#include "grpc/grpc.h"
+#include "grpc/grpc_security.h"
+#include "grpc/support/alloc.h"
+#include "grpc/support/log.h"
+#include "grpc/support/time.h"
#include "slice.h"
#include "timeval.h"
@@ -101,20 +101,20 @@
HandleScope scope;
Local<Array> keys = Nan::GetOwnPropertyNames(metadata).ToLocalChecked();
for (unsigned int i = 0; i < keys->Length(); i++) {
- Local<String> current_key = Nan::To<String>(
- Nan::Get(keys, i).ToLocalChecked()).ToLocalChecked();
+ Local<String> current_key =
+ Nan::To<String>(Nan::Get(keys, i).ToLocalChecked()).ToLocalChecked();
Local<Value> value_array = Nan::Get(metadata, current_key).ToLocalChecked();
if (!value_array->IsArray()) {
return false;
}
array->capacity += Local<Array>::Cast(value_array)->Length();
}
- array->metadata = reinterpret_cast<grpc_metadata*>(
+ array->metadata = reinterpret_cast<grpc_metadata *>(
gpr_zalloc(array->capacity * sizeof(grpc_metadata)));
for (unsigned int i = 0; i < keys->Length(); i++) {
Local<String> current_key(Nan::To<String>(keys->Get(i)).ToLocalChecked());
- Local<Array> values = Local<Array>::Cast(
- Nan::Get(metadata, current_key).ToLocalChecked());
+ Local<Array> values =
+ Local<Array>::Cast(Nan::Get(metadata, current_key).ToLocalChecked());
grpc_slice key_slice = CreateSliceFromString(current_key);
grpc_slice key_intern_slice = grpc_slice_intern(key_slice);
grpc_slice_unref(key_slice);
@@ -157,7 +157,7 @@
size_t length = metadata_array->count;
Local<Object> metadata_object = Nan::New<Object>();
for (unsigned int i = 0; i < length; i++) {
- grpc_metadata* elem = &metadata_elements[i];
+ grpc_metadata *elem = &metadata_elements[i];
// TODO(murgatroid99): Use zero-copy string construction instead
Local<String> key_string = CopyStringFromSlice(elem->key);
Local<Array> array;
@@ -183,17 +183,12 @@
return scope.Escape(Nan::New(GetTypeString()).ToLocalChecked());
}
-Op::~Op() {
-}
+Op::~Op() {}
class SendMetadataOp : public Op {
public:
- SendMetadataOp() {
- grpc_metadata_array_init(&send_metadata);
- }
- ~SendMetadataOp() {
- DestroyMetadataArray(&send_metadata);
- }
+ SendMetadataOp() { grpc_metadata_array_init(&send_metadata); }
+ ~SendMetadataOp() { DestroyMetadataArray(&send_metadata); }
Local<Value> GetNodeValue() const {
EscapableHandleScope scope;
return scope.Escape(Nan::True());
@@ -206,32 +201,26 @@
if (maybe_metadata.IsEmpty()) {
return false;
}
- if (!CreateMetadataArray(maybe_metadata.ToLocalChecked(),
- &send_metadata)) {
+ if (!CreateMetadataArray(maybe_metadata.ToLocalChecked(), &send_metadata)) {
return false;
}
out->data.send_initial_metadata.count = send_metadata.count;
out->data.send_initial_metadata.metadata = send_metadata.metadata;
return true;
}
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
+
protected:
- std::string GetTypeString() const {
- return "send_metadata";
- }
+ std::string GetTypeString() const { return "send_metadata"; }
+
private:
grpc_metadata_array send_metadata;
};
class SendMessageOp : public Op {
public:
- SendMessageOp() {
- send_message = NULL;
- }
+ SendMessageOp() { send_message = NULL; }
~SendMessageOp() {
if (send_message != NULL) {
grpc_byte_buffer_destroy(send_message);
@@ -246,8 +235,8 @@
return false;
}
Local<Object> object_value = Nan::To<Object>(value).ToLocalChecked();
- MaybeLocal<Value> maybe_flag_value = Nan::Get(
- object_value, Nan::New("grpcWriteFlags").ToLocalChecked());
+ MaybeLocal<Value> maybe_flag_value =
+ Nan::Get(object_value, Nan::New("grpcWriteFlags").ToLocalChecked());
if (!maybe_flag_value.IsEmpty()) {
Local<Value> flag_value = maybe_flag_value.ToLocalChecked();
if (flag_value->IsUint32()) {
@@ -259,15 +248,12 @@
out->data.send_message.send_message = send_message;
return true;
}
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
+
protected:
- std::string GetTypeString() const {
- return "send_message";
- }
+ std::string GetTypeString() const { return "send_message"; }
+
private:
grpc_byte_buffer *send_message;
};
@@ -278,25 +264,17 @@
EscapableHandleScope scope;
return scope.Escape(Nan::True());
}
- bool ParseOp(Local<Value> value, grpc_op *out) {
- return true;
- }
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
+
protected:
- std::string GetTypeString() const {
- return "client_close";
- }
+ std::string GetTypeString() const { return "client_close"; }
};
class SendServerStatusOp : public Op {
public:
- SendServerStatusOp() {
- grpc_metadata_array_init(&status_metadata);
- }
+ SendServerStatusOp() { grpc_metadata_array_init(&status_metadata); }
~SendServerStatusOp() {
grpc_slice_unref(details);
DestroyMetadataArray(&status_metadata);
@@ -310,18 +288,18 @@
return false;
}
Local<Object> server_status = Nan::To<Object>(value).ToLocalChecked();
- MaybeLocal<Value> maybe_metadata = Nan::Get(
- server_status, Nan::New("metadata").ToLocalChecked());
+ MaybeLocal<Value> maybe_metadata =
+ Nan::Get(server_status, Nan::New("metadata").ToLocalChecked());
if (maybe_metadata.IsEmpty()) {
return false;
}
if (!maybe_metadata.ToLocalChecked()->IsObject()) {
return false;
}
- Local<Object> metadata = Nan::To<Object>(
- maybe_metadata.ToLocalChecked()).ToLocalChecked();
- MaybeLocal<Value> maybe_code = Nan::Get(server_status,
- Nan::New("code").ToLocalChecked());
+ Local<Object> metadata =
+ Nan::To<Object>(maybe_metadata.ToLocalChecked()).ToLocalChecked();
+ MaybeLocal<Value> maybe_code =
+ Nan::Get(server_status, Nan::New("code").ToLocalChecked());
if (maybe_code.IsEmpty()) {
return false;
}
@@ -329,16 +307,16 @@
return false;
}
uint32_t code = Nan::To<uint32_t>(maybe_code.ToLocalChecked()).FromJust();
- MaybeLocal<Value> maybe_details = Nan::Get(
- server_status, Nan::New("details").ToLocalChecked());
+ MaybeLocal<Value> maybe_details =
+ Nan::Get(server_status, Nan::New("details").ToLocalChecked());
if (maybe_details.IsEmpty()) {
return false;
}
if (!maybe_details.ToLocalChecked()->IsString()) {
return false;
}
- Local<String> details = Nan::To<String>(
- maybe_details.ToLocalChecked()).ToLocalChecked();
+ Local<String> details =
+ Nan::To<String>(maybe_details.ToLocalChecked()).ToLocalChecked();
if (!CreateMetadataArray(metadata, &status_metadata)) {
return false;
}
@@ -352,15 +330,11 @@
out->data.send_status_from_server.status_details = &this->details;
return true;
}
- bool IsFinalOp() {
- return true;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return true; }
+ void OnComplete(bool success) {}
+
protected:
- std::string GetTypeString() const {
- return "send_status";
- }
+ std::string GetTypeString() const { return "send_status"; }
private:
grpc_slice details;
@@ -369,13 +343,9 @@
class GetMetadataOp : public Op {
public:
- GetMetadataOp() {
- grpc_metadata_array_init(&recv_metadata);
- }
+ GetMetadataOp() { grpc_metadata_array_init(&recv_metadata); }
- ~GetMetadataOp() {
- grpc_metadata_array_destroy(&recv_metadata);
- }
+ ~GetMetadataOp() { grpc_metadata_array_destroy(&recv_metadata); }
Local<Value> GetNodeValue() const {
EscapableHandleScope scope;
@@ -386,16 +356,11 @@
out->data.recv_initial_metadata.recv_initial_metadata = &recv_metadata;
return true;
}
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
protected:
- std::string GetTypeString() const {
- return "metadata";
- }
+ std::string GetTypeString() const { return "metadata"; }
private:
grpc_metadata_array recv_metadata;
@@ -403,9 +368,7 @@
class ReadMessageOp : public Op {
public:
- ReadMessageOp() {
- recv_message = NULL;
- }
+ ReadMessageOp() { recv_message = NULL; }
~ReadMessageOp() {
if (recv_message != NULL) {
grpc_byte_buffer_destroy(recv_message);
@@ -420,16 +383,11 @@
out->data.recv_message.recv_message = &recv_message;
return true;
}
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
protected:
- std::string GetTypeString() const {
- return "read";
- }
+ std::string GetTypeString() const { return "read"; }
private:
grpc_byte_buffer *recv_message;
@@ -437,13 +395,9 @@
class ClientStatusOp : public Op {
public:
- ClientStatusOp() {
- grpc_metadata_array_init(&metadata_array);
- }
+ ClientStatusOp() { grpc_metadata_array_init(&metadata_array); }
- ~ClientStatusOp() {
- grpc_metadata_array_destroy(&metadata_array);
- }
+ ~ClientStatusOp() { grpc_metadata_array_destroy(&metadata_array); }
bool ParseOp(Local<Value> value, grpc_op *out) {
out->data.recv_status_on_client.trailing_metadata = &metadata_array;
@@ -456,22 +410,19 @@
EscapableHandleScope scope;
Local<Object> status_obj = Nan::New<Object>();
Nan::Set(status_obj, Nan::New("code").ToLocalChecked(),
- Nan::New<Number>(status));
+ Nan::New<Number>(status));
Nan::Set(status_obj, Nan::New("details").ToLocalChecked(),
- CopyStringFromSlice(status_details));
+ CopyStringFromSlice(status_details));
Nan::Set(status_obj, Nan::New("metadata").ToLocalChecked(),
ParseMetadata(&metadata_array));
return scope.Escape(status_obj);
}
- bool IsFinalOp() {
- return true;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return true; }
+ void OnComplete(bool success) {}
+
protected:
- std::string GetTypeString() const {
- return "status";
- }
+ std::string GetTypeString() const { return "status"; }
+
private:
grpc_metadata_array metadata_array;
grpc_status_code status;
@@ -489,23 +440,18 @@
out->data.recv_close_on_server.cancelled = &cancelled;
return true;
}
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
protected:
- std::string GetTypeString() const {
- return "cancelled";
- }
+ std::string GetTypeString() const { return "cancelled"; }
private:
int cancelled;
};
-tag::tag(Callback *callback, OpVec *ops, Call *call, Local<Value> call_value) :
- callback(callback), ops(ops), call(call){
+tag::tag(Callback *callback, OpVec *ops, Call *call, Local<Value> call_value)
+ : callback(callback), ops(ops), call(call) {
HandleScope scope;
call_persist.Reset(call_value);
}
@@ -560,14 +506,10 @@
}
}
-Call::Call(grpc_call *call) : wrapped_call(call),
- pending_batches(0),
- has_final_op_completed(false) {
-}
+Call::Call(grpc_call *call)
+ : wrapped_call(call), pending_batches(0), has_final_op_completed(false) {}
-Call::~Call() {
- DestroyCall();
-}
+Call::~Call() { DestroyCall(); }
void Call::Init(Local<Object> exports) {
HandleScope scope;
@@ -596,10 +538,10 @@
return scope.Escape(Nan::Null());
}
const int argc = 1;
- Local<Value> argv[argc] = {Nan::New<External>(
- reinterpret_cast<void *>(call))};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ Local<Value> argv[argc] = {
+ Nan::New<External>(reinterpret_cast<void *>(call))};
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null());
} else {
@@ -631,8 +573,7 @@
if (info[0]->IsExternal()) {
Local<External> ext = info[0].As<External>();
// This option is used for wrapping an existing call
- grpc_call *call_value =
- reinterpret_cast<grpc_call *>(ext->Value());
+ grpc_call *call_value = reinterpret_cast<grpc_call *>(ext->Value());
call = new Call(call_value);
} else {
if (!Channel::HasInstance(info[0])) {
@@ -648,8 +589,8 @@
// These arguments are at the end because they are optional
grpc_call *parent_call = NULL;
if (Call::HasInstance(info[4])) {
- Call *parent_obj = ObjectWrap::Unwrap<Call>(
- Nan::To<Object>(info[4]).ToLocalChecked());
+ Call *parent_obj =
+ ObjectWrap::Unwrap<Call>(Nan::To<Object>(info[4]).ToLocalChecked());
parent_call = parent_obj->wrapped_call;
} else if (!(info[4]->IsUndefined() || info[4]->IsNull())) {
return Nan::ThrowTypeError(
@@ -670,22 +611,20 @@
double deadline = Nan::To<double>(info[2]).FromJust();
grpc_channel *wrapped_channel = channel->GetWrappedChannel();
grpc_call *wrapped_call;
- grpc_slice method = CreateSliceFromString(
- Nan::To<String>(info[1]).ToLocalChecked());
+ grpc_slice method =
+ CreateSliceFromString(Nan::To<String>(info[1]).ToLocalChecked());
if (info[3]->IsString()) {
grpc_slice *host = new grpc_slice;
- *host = CreateSliceFromString(
- Nan::To<String>(info[3]).ToLocalChecked());
+ *host =
+ CreateSliceFromString(Nan::To<String>(info[3]).ToLocalChecked());
wrapped_call = grpc_channel_create_call(
- wrapped_channel, parent_call, propagate_flags,
- GetCompletionQueue(), method,
- host, MillisecondsToTimespec(deadline), NULL);
+ wrapped_channel, parent_call, propagate_flags, GetCompletionQueue(),
+ method, host, MillisecondsToTimespec(deadline), NULL);
delete host;
} else if (info[3]->IsUndefined() || info[3]->IsNull()) {
wrapped_call = grpc_channel_create_call(
- wrapped_channel, parent_call, propagate_flags,
- GetCompletionQueue(), method,
- NULL, MillisecondsToTimespec(deadline), NULL);
+ wrapped_channel, parent_call, propagate_flags, GetCompletionQueue(),
+ method, NULL, MillisecondsToTimespec(deadline), NULL);
} else {
return Nan::ThrowTypeError("Call's fourth argument must be a string");
}
@@ -699,8 +638,8 @@
} else {
const int argc = 4;
Local<Value> argv[argc] = {info[0], info[1], info[2], info[3]};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
// There's probably a pending exception
return;
@@ -773,8 +712,8 @@
}
Callback *callback = new Callback(callback_func);
grpc_call_error error = grpc_call_start_batch(
- call->wrapped_call, &ops[0], nops, new struct tag(
- callback, op_vector.release(), call, info.This()), NULL);
+ call->wrapped_call, &ops[0], nops,
+ new struct tag(callback, op_vector.release(), call, info.This()), NULL);
if (error != GRPC_CALL_OK) {
return Nan::ThrowError(nanErrorWithCode("startBatch failed", error));
}
@@ -807,8 +746,8 @@
"cancelWithStatus's second argument must be a string");
}
Call *call = ObjectWrap::Unwrap<Call>(info.This());
- grpc_status_code code = static_cast<grpc_status_code>(
- Nan::To<uint32_t>(info[0]).FromJust());
+ grpc_status_code code =
+ static_cast<grpc_status_code>(Nan::To<uint32_t>(info[0]).FromJust());
if (code == GRPC_STATUS_OK) {
return Nan::ThrowRangeError(
"cancelWithStatus cannot be called with OK status");
diff --git a/src/node/ext/call.h b/src/node/ext/call.h
index 340e326..0bd24f5 100644
--- a/src/node/ext/call.h
+++ b/src/node/ext/call.h
@@ -37,14 +37,13 @@
#include <memory>
#include <vector>
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
#include "grpc/support/log.h"
#include "channel.h"
-
namespace grpc {
namespace node {
diff --git a/src/node/ext/call_credentials.cc b/src/node/ext/call_credentials.cc
index 5bd4bdc..f88eb82 100644
--- a/src/node/ext/call_credentials.cc
+++ b/src/node/ext/call_credentials.cc
@@ -31,17 +31,17 @@
*
*/
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include <uv.h>
#include <queue>
+#include "call.h"
+#include "call_credentials.h"
#include "grpc/grpc.h"
#include "grpc/grpc_security.h"
#include "grpc/support/log.h"
-#include "call_credentials.h"
-#include "call.h"
namespace grpc {
namespace node {
@@ -86,15 +86,15 @@
fun_tpl.Reset(tpl);
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
Nan::Set(ctr, Nan::New("createFromPlugin").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(CreateFromPlugin)).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(CreateFromPlugin))
+ .ToLocalChecked());
Nan::Set(exports, Nan::New("CallCredentials").ToLocalChecked(), ctr);
constructor = new Nan::Callback(ctr);
Local<FunctionTemplate> callback_tpl =
Nan::New<FunctionTemplate>(PluginCallback);
- plugin_callback = new Callback(
- Nan::GetFunction(callback_tpl).ToLocalChecked());
+ plugin_callback =
+ new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
}
bool CallCredentials::HasInstance(Local<Value> val) {
@@ -109,9 +109,9 @@
return scope.Escape(Nan::Null());
}
Local<Value> argv[argc] = {
- Nan::New<External>(reinterpret_cast<void *>(credentials))};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ Nan::New<External>(reinterpret_cast<void *>(credentials))};
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null());
} else {
@@ -160,8 +160,6 @@
info.GetReturnValue().Set(WrapStruct(creds));
}
-
-
NAN_METHOD(CallCredentials::CreateFromPlugin) {
if (!info[0]->IsFunction()) {
return Nan::ThrowTypeError(
@@ -170,21 +168,19 @@
grpc_metadata_credentials_plugin plugin;
plugin_state *state = new plugin_state;
state->callback = new Nan::Callback(info[0].As<Function>());
- state->pending_callbacks = new std::queue<plugin_callback_data*>();
+ state->pending_callbacks = new std::queue<plugin_callback_data *>();
uv_mutex_init(&state->plugin_mutex);
- uv_async_init(uv_default_loop(),
- &state->plugin_async,
- SendPluginCallback);
- uv_unref((uv_handle_t*)&state->plugin_async);
+ uv_async_init(uv_default_loop(), &state->plugin_async, SendPluginCallback);
+ uv_unref((uv_handle_t *)&state->plugin_async);
state->plugin_async.data = state;
plugin.get_metadata = plugin_get_metadata;
plugin.destroy = plugin_destroy_state;
- plugin.state = reinterpret_cast<void*>(state);
+ plugin.state = reinterpret_cast<void *>(state);
plugin.type = "";
- grpc_call_credentials *creds = grpc_metadata_credentials_create_from_plugin(
- plugin, NULL);
+ grpc_call_credentials *creds =
+ grpc_metadata_credentials_create_from_plugin(plugin, NULL);
info.GetReturnValue().Set(WrapStruct(creds));
}
@@ -206,34 +202,35 @@
return Nan::ThrowTypeError(
"The callback's fourth argument must be an object");
}
- grpc_status_code code = static_cast<grpc_status_code>(
- Nan::To<uint32_t>(info[0]).FromJust());
+ grpc_status_code code =
+ static_cast<grpc_status_code>(Nan::To<uint32_t>(info[0]).FromJust());
Utf8String details_utf8_str(info[1]);
char *details = *details_utf8_str;
grpc_metadata_array array;
grpc_metadata_array_init(&array);
Local<Object> callback_data = Nan::To<Object>(info[3]).ToLocalChecked();
- if (!CreateMetadataArray(Nan::To<Object>(info[2]).ToLocalChecked(),
- &array)){
+ if (!CreateMetadataArray(Nan::To<Object>(info[2]).ToLocalChecked(), &array)) {
return Nan::ThrowError("Failed to parse metadata");
}
grpc_credentials_plugin_metadata_cb cb =
reinterpret_cast<grpc_credentials_plugin_metadata_cb>(
- Nan::Get(callback_data,
- Nan::New("cb").ToLocalChecked()
- ).ToLocalChecked().As<External>()->Value());
+ Nan::Get(callback_data, Nan::New("cb").ToLocalChecked())
+ .ToLocalChecked()
+ .As<External>()
+ ->Value());
void *user_data =
- Nan::Get(callback_data,
- Nan::New("user_data").ToLocalChecked()
- ).ToLocalChecked().As<External>()->Value();
+ Nan::Get(callback_data, Nan::New("user_data").ToLocalChecked())
+ .ToLocalChecked()
+ .As<External>()
+ ->Value();
cb(user_data, array.metadata, array.count, code, details);
DestroyMetadataArray(&array);
}
NAUV_WORK_CB(SendPluginCallback) {
Nan::HandleScope scope;
- plugin_state *state = reinterpret_cast<plugin_state*>(async->data);
- std::queue<plugin_callback_data*> callbacks;
+ plugin_state *state = reinterpret_cast<plugin_state *>(async->data);
+ std::queue<plugin_callback_data *> callbacks;
uv_mutex_lock(&state->plugin_mutex);
state->pending_callbacks->swap(callbacks);
uv_mutex_unlock(&state->plugin_mutex);
@@ -242,16 +239,14 @@
callbacks.pop();
Local<Object> callback_data = Nan::New<Object>();
Nan::Set(callback_data, Nan::New("cb").ToLocalChecked(),
- Nan::New<v8::External>(reinterpret_cast<void*>(data->cb)));
+ Nan::New<v8::External>(reinterpret_cast<void *>(data->cb)));
Nan::Set(callback_data, Nan::New("user_data").ToLocalChecked(),
Nan::New<v8::External>(data->user_data));
const int argc = 3;
v8::Local<v8::Value> argv[argc] = {
- Nan::New(data->service_url).ToLocalChecked(),
- callback_data,
- // Get Local<Function> from Nan::Callback*
- **plugin_callback
- };
+ Nan::New(data->service_url).ToLocalChecked(), callback_data,
+ // Get Local<Function> from Nan::Callback*
+ **plugin_callback};
Nan::Callback *callback = state->callback;
callback->Call(argc, argv);
delete data;
@@ -261,7 +256,7 @@
void plugin_get_metadata(void *state, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb,
void *user_data) {
- plugin_state *p_state = reinterpret_cast<plugin_state*>(state);
+ plugin_state *p_state = reinterpret_cast<plugin_state *>(state);
plugin_callback_data *data = new plugin_callback_data;
data->service_url = context.service_url;
data->cb = cb;
@@ -275,7 +270,7 @@
}
void plugin_uv_close_cb(uv_handle_t *handle) {
- uv_async_t *async = reinterpret_cast<uv_async_t*>(handle);
+ uv_async_t *async = reinterpret_cast<uv_async_t *>(handle);
plugin_state *state = reinterpret_cast<plugin_state *>(async->data);
uv_mutex_destroy(&state->plugin_mutex);
delete state->pending_callbacks;
@@ -285,7 +280,7 @@
void plugin_destroy_state(void *ptr) {
plugin_state *state = reinterpret_cast<plugin_state *>(ptr);
- uv_close((uv_handle_t*)&state->plugin_async, plugin_uv_close_cb);
+ uv_close((uv_handle_t *)&state->plugin_async, plugin_uv_close_cb);
}
} // namespace node
diff --git a/src/node/ext/call_credentials.h b/src/node/ext/call_credentials.h
index 21a4b89..5a1741c 100644
--- a/src/node/ext/call_credentials.h
+++ b/src/node/ext/call_credentials.h
@@ -36,8 +36,8 @@
#include <queue>
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include <uv.h>
#include "grpc/grpc_security.h"
@@ -84,7 +84,7 @@
typedef struct plugin_state {
Nan::Callback *callback;
- std::queue<plugin_callback_data*> *pending_callbacks;
+ std::queue<plugin_callback_data *> *pending_callbacks;
uv_mutex_t plugin_mutex;
// async.data == this
uv_async_t plugin_async;
diff --git a/src/node/ext/channel.cc b/src/node/ext/channel.cc
index 1263cc0..be04cf4 100644
--- a/src/node/ext/channel.cc
+++ b/src/node/ext/channel.cc
@@ -35,15 +35,15 @@
#include "grpc/support/log.h"
-#include <node.h>
#include <nan.h>
-#include "grpc/grpc.h"
-#include "grpc/grpc_security.h"
+#include <node.h>
#include "call.h"
#include "channel.h"
+#include "channel_credentials.h"
#include "completion_queue.h"
#include "completion_queue_async_worker.h"
-#include "channel_credentials.h"
+#include "grpc/grpc.h"
+#include "grpc/grpc_security.h"
#include "timeval.h"
namespace grpc {
@@ -82,8 +82,8 @@
*channel_args_ptr = NULL;
return false;
}
- grpc_channel_args *channel_args = reinterpret_cast<grpc_channel_args*>(
- malloc(sizeof(grpc_channel_args)));
+ grpc_channel_args *channel_args =
+ reinterpret_cast<grpc_channel_args *>(malloc(sizeof(grpc_channel_args)));
*channel_args_ptr = channel_args;
Local<Object> args_hash = Nan::To<Object>(args_val).ToLocalChecked();
Local<Array> keys = Nan::GetOwnPropertyNames(args_hash).ToLocalChecked();
@@ -104,16 +104,16 @@
} else if (value->IsString()) {
Utf8String val_str(value);
channel_args->args[i].type = GRPC_ARG_STRING;
- channel_args->args[i].value.string = reinterpret_cast<char*>(
- calloc(val_str.length() + 1,sizeof(char)));
- memcpy(channel_args->args[i].value.string,
- *val_str, val_str.length() + 1);
+ channel_args->args[i].value.string =
+ reinterpret_cast<char *>(calloc(val_str.length() + 1, sizeof(char)));
+ memcpy(channel_args->args[i].value.string, *val_str,
+ val_str.length() + 1);
} else {
// The value does not match either of the accepted types
return false;
}
- channel_args->args[i].key = reinterpret_cast<char*>(
- calloc(key_str.length() + 1, sizeof(char)));
+ channel_args->args[i].key =
+ reinterpret_cast<char *>(calloc(key_str.length() + 1, sizeof(char)));
memcpy(channel_args->args[i].key, *key_str, key_str.length() + 1);
}
return true;
@@ -190,12 +190,13 @@
grpc_channel_args *channel_args_ptr = NULL;
if (!ParseChannelArgs(info[2], &channel_args_ptr)) {
DeallocateChannelArgs(channel_args_ptr);
- return Nan::ThrowTypeError("Channel options must be an object with "
- "string keys and integer or string values");
+ return Nan::ThrowTypeError(
+ "Channel options must be an object with "
+ "string keys and integer or string values");
}
if (creds == NULL) {
- wrapped_channel = grpc_insecure_channel_create(*host, channel_args_ptr,
- NULL);
+ wrapped_channel =
+ grpc_insecure_channel_create(*host, channel_args_ptr, NULL);
} else {
wrapped_channel =
grpc_secure_channel_create(creds, *host, channel_args_ptr, NULL);
@@ -208,8 +209,8 @@
} else {
const int argc = 3;
Local<Value> argv[argc] = {info[0], info[1], info[2]};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
// There's probably a pending exception
return;
@@ -232,11 +233,13 @@
NAN_METHOD(Channel::GetTarget) {
if (!HasInstance(info.This())) {
- return Nan::ThrowTypeError("getTarget can only be called on Channel objects");
+ return Nan::ThrowTypeError(
+ "getTarget can only be called on Channel objects");
}
Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
- info.GetReturnValue().Set(Nan::New(
- grpc_channel_get_target(channel->wrapped_channel)).ToLocalChecked());
+ info.GetReturnValue().Set(
+ Nan::New(grpc_channel_get_target(channel->wrapped_channel))
+ .ToLocalChecked());
}
NAN_METHOD(Channel::GetConnectivityState) {
@@ -246,9 +249,8 @@
}
Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
int try_to_connect = (int)info[0]->Equals(Nan::True());
- info.GetReturnValue().Set(
- grpc_channel_check_connectivity_state(channel->wrapped_channel,
- try_to_connect));
+ info.GetReturnValue().Set(grpc_channel_check_connectivity_state(
+ channel->wrapped_channel, try_to_connect));
}
NAN_METHOD(Channel::WatchConnectivityState) {
@@ -268,9 +270,8 @@
return Nan::ThrowTypeError(
"watchConnectivityState's third argument must be a callback");
}
- grpc_connectivity_state last_state =
- static_cast<grpc_connectivity_state>(
- Nan::To<uint32_t>(info[0]).FromJust());
+ grpc_connectivity_state last_state = static_cast<grpc_connectivity_state>(
+ Nan::To<uint32_t>(info[0]).FromJust());
double deadline = Nan::To<double>(info[1]).FromJust();
Local<Function> callback_func = info[2].As<Function>();
Nan::Callback *callback = new Callback(callback_func);
@@ -279,8 +280,7 @@
grpc_channel_watch_connectivity_state(
channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline),
GetCompletionQueue(),
- new struct tag(callback,
- ops.release(), NULL, Nan::Null()));
+ new struct tag(callback, ops.release(), NULL, Nan::Null()));
CompletionQueueNext();
}
diff --git a/src/node/ext/channel.h b/src/node/ext/channel.h
index 9ec28e1..6d42a5e 100644
--- a/src/node/ext/channel.h
+++ b/src/node/ext/channel.h
@@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_CHANNEL_H_
#define NET_GRPC_NODE_CHANNEL_H_
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
namespace grpc {
diff --git a/src/node/ext/channel_credentials.cc b/src/node/ext/channel_credentials.cc
index 059bc8a..cf1dc31 100644
--- a/src/node/ext/channel_credentials.cc
+++ b/src/node/ext/channel_credentials.cc
@@ -33,12 +33,12 @@
#include <node.h>
+#include "call.h"
+#include "call_credentials.h"
+#include "channel_credentials.h"
#include "grpc/grpc.h"
#include "grpc/grpc_security.h"
#include "grpc/support/log.h"
-#include "channel_credentials.h"
-#include "call_credentials.h"
-#include "call.h"
namespace grpc {
namespace node {
@@ -80,12 +80,12 @@
Nan::SetPrototypeMethod(tpl, "compose", Compose);
fun_tpl.Reset(tpl);
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
- Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
+ Nan::Set(
+ ctr, Nan::New("createSsl").ToLocalChecked(),
+ Nan::GetFunction(Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(CreateInsecure))
+ .ToLocalChecked());
Nan::Set(exports, Nan::New("ChannelCredentials").ToLocalChecked(), ctr);
constructor = new Nan::Callback(ctr);
}
@@ -100,9 +100,9 @@
EscapableHandleScope scope;
const int argc = 1;
Local<Value> argv[argc] = {
- Nan::New<External>(reinterpret_cast<void *>(credentials))};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ Nan::New<External>(reinterpret_cast<void *>(credentials))};
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null());
} else {
@@ -179,11 +179,10 @@
return Nan::ThrowTypeError(
"compose's first argument must be a CallCredentials object");
}
- ChannelCredentials *self = ObjectWrap::Unwrap<ChannelCredentials>(
- info.This());
+ ChannelCredentials *self =
+ ObjectWrap::Unwrap<ChannelCredentials>(info.This());
if (self->wrapped_credentials == NULL) {
- return Nan::ThrowTypeError(
- "Cannot compose insecure credential");
+ return Nan::ThrowTypeError("Cannot compose insecure credential");
}
CallCredentials *other = ObjectWrap::Unwrap<CallCredentials>(
Nan::To<Object>(info[0]).ToLocalChecked());
diff --git a/src/node/ext/channel_credentials.h b/src/node/ext/channel_credentials.h
index 89b1152..e5c7439 100644
--- a/src/node/ext/channel_credentials.h
+++ b/src/node/ext/channel_credentials.h
@@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_
#define NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
#include "grpc/grpc_security.h"
diff --git a/src/node/ext/completion_queue.h b/src/node/ext/completion_queue.h
index 9b01028..a3a055c 100644
--- a/src/node/ext/completion_queue.h
+++ b/src/node/ext/completion_queue.h
@@ -31,8 +31,8 @@
*
*/
-#include <v8.h>
#include <grpc/grpc.h>
+#include <v8.h>
namespace grpc {
namespace node {
diff --git a/src/node/ext/node_grpc.cc b/src/node/ext/node_grpc.cc
index 122e5e6..076f1ed 100644
--- a/src/node/ext/node_grpc.cc
+++ b/src/node/ext/node_grpc.cc
@@ -33,8 +33,8 @@
#include <queue>
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include <v8.h>
#include "grpc/grpc.h"
#include "grpc/grpc_security.h"
@@ -53,12 +53,12 @@
#include "call_credentials.h"
#include "channel.h"
#include "channel_credentials.h"
-#include "server.h"
+#include "completion_queue.h"
#include "completion_queue_async_worker.h"
+#include "server.h"
#include "server_credentials.h"
#include "slice.h"
#include "timeval.h"
-#include "completion_queue.h"
using grpc::node::CreateSliceFromString;
@@ -188,8 +188,7 @@
Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA));
Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(),
SEND_INITIAL_METADATA);
- Local<Value> SEND_MESSAGE(
- Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
+ Local<Value> SEND_MESSAGE(Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE);
Local<Value> SEND_CLOSE_FROM_CLIENT(
Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
@@ -203,8 +202,7 @@
Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA));
Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(),
RECV_INITIAL_METADATA);
- Local<Value> RECV_MESSAGE(
- Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
+ Local<Value> RECV_MESSAGE(Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE);
Local<Value> RECV_STATUS_ON_CLIENT(
Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT));
@@ -252,8 +250,7 @@
Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE));
Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(),
TRANSIENT_FAILURE);
- Local<Value> FATAL_FAILURE(
- Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_SHUTDOWN));
+ Local<Value> FATAL_FAILURE(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_SHUTDOWN));
Nan::Set(channel_state, Nan::New("FATAL_FAILURE").ToLocalChecked(),
FATAL_FAILURE);
}
@@ -282,13 +279,11 @@
NAN_METHOD(MetadataKeyIsLegal) {
if (!info[0]->IsString()) {
- return Nan::ThrowTypeError(
- "headerKeyIsLegal's argument must be a string");
+ return Nan::ThrowTypeError("headerKeyIsLegal's argument must be a string");
}
Local<String> key = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(key);
- info.GetReturnValue().Set(static_cast<bool>(
- grpc_header_key_is_legal(slice)));
+ info.GetReturnValue().Set(static_cast<bool>(grpc_header_key_is_legal(slice)));
grpc_slice_unref(slice);
}
@@ -299,8 +294,8 @@
}
Local<String> value = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(value);
- info.GetReturnValue().Set(static_cast<bool>(
- grpc_header_nonbin_value_is_legal(slice)));
+ info.GetReturnValue().Set(
+ static_cast<bool>(grpc_header_nonbin_value_is_legal(slice)));
grpc_slice_unref(slice);
}
@@ -311,8 +306,7 @@
}
Local<String> key = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(key);
- info.GetReturnValue().Set(static_cast<bool>(
- grpc_is_binary_header(slice)));
+ info.GetReturnValue().Set(static_cast<bool>(grpc_is_binary_header(slice)));
grpc_slice_unref(slice);
}
@@ -354,11 +348,13 @@
args.pop();
Local<Value> file = Nan::New(arg->core_args.file).ToLocalChecked();
Local<Value> line = Nan::New<Uint32, uint32_t>(arg->core_args.line);
- Local<Value> severity = Nan::New(
- gpr_log_severity_string(arg->core_args.severity)).ToLocalChecked();
+ Local<Value> severity =
+ Nan::New(gpr_log_severity_string(arg->core_args.severity))
+ .ToLocalChecked();
Local<Value> message = Nan::New(arg->core_args.message).ToLocalChecked();
- Local<Value> timestamp = Nan::New<v8::Date>(
- grpc::node::TimespecToMilliseconds(arg->timestamp)).ToLocalChecked();
+ Local<Value> timestamp =
+ Nan::New<v8::Date>(grpc::node::TimespecToMilliseconds(arg->timestamp))
+ .ToLocalChecked();
const int argc = 5;
Local<Value> argv[argc] = {file, line, severity, message, timestamp};
grpc_logger_state.callback->Call(argc, argv);
@@ -388,10 +384,9 @@
memset(&grpc_logger_state, 0, sizeof(logger_state));
grpc_logger_state.pending_args = new std::queue<log_args *>();
uv_mutex_init(&grpc_logger_state.mutex);
- uv_async_init(uv_default_loop(),
- &grpc_logger_state.async,
+ uv_async_init(uv_default_loop(), &grpc_logger_state.async,
LogMessagesCallback);
- uv_unref((uv_handle_t*)&grpc_logger_state.async);
+ uv_unref((uv_handle_t *)&grpc_logger_state.async);
grpc_logger_state.logger_set = false;
gpr_log_verbosity_init();
@@ -416,11 +411,10 @@
NAN_METHOD(SetLogVerbosity) {
if (!info[0]->IsUint32()) {
- return Nan::ThrowTypeError(
- "setLogVerbosity's argument must be a number");
+ return Nan::ThrowTypeError("setLogVerbosity's argument must be a number");
}
- gpr_log_severity severity = static_cast<gpr_log_severity>(
- Nan::To<uint32_t>(info[0]).FromJust());
+ gpr_log_severity severity =
+ static_cast<gpr_log_severity>(Nan::To<uint32_t>(info[0]).FromJust());
gpr_set_log_verbosity(severity);
}
@@ -453,28 +447,25 @@
// Attach a few utility functions directly to the module
Nan::Set(exports, Nan::New("metadataKeyIsLegal").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(MetadataKeyIsLegal)).ToLocalChecked());
- Nan::Set(exports, Nan::New("metadataNonbinValueIsLegal").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(MetadataNonbinValueIsLegal)
- ).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataKeyIsLegal))
+ .ToLocalChecked());
+ Nan::Set(
+ exports, Nan::New("metadataNonbinValueIsLegal").ToLocalChecked(),
+ Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataNonbinValueIsLegal))
+ .ToLocalChecked());
Nan::Set(exports, Nan::New("metadataKeyIsBinary").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(MetadataKeyIsBinary)
- ).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataKeyIsBinary))
+ .ToLocalChecked());
Nan::Set(exports, Nan::New("setDefaultRootsPem").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(SetDefaultRootsPem)
- ).ToLocalChecked());
- Nan::Set(exports, Nan::New("setDefaultLoggerCallback").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(SetDefaultLoggerCallback)
- ).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(SetDefaultRootsPem))
+ .ToLocalChecked());
+ Nan::Set(
+ exports, Nan::New("setDefaultLoggerCallback").ToLocalChecked(),
+ Nan::GetFunction(Nan::New<FunctionTemplate>(SetDefaultLoggerCallback))
+ .ToLocalChecked());
Nan::Set(exports, Nan::New("setLogVerbosity").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(SetLogVerbosity)
- ).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(SetLogVerbosity))
+ .ToLocalChecked());
}
NODE_MODULE(grpc_node, init)
diff --git a/src/node/ext/server.cc b/src/node/ext/server.cc
index 5384305..1871a32 100644
--- a/src/node/ext/server.cc
+++ b/src/node/ext/server.cc
@@ -111,14 +111,9 @@
return scope.Escape(obj);
}
- bool ParseOp(Local<Value> value, grpc_op *out) {
- return true;
- }
- bool IsFinalOp() {
- return false;
- }
- void OnComplete(bool success) {
- }
+ bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
+ bool IsFinalOp() { return false; }
+ void OnComplete(bool success) {}
grpc_call *call;
grpc_call_details details;
@@ -128,7 +123,7 @@
std::string GetTypeString() const { return "new_call"; }
};
-class TryShutdownOp: public Op {
+class TryShutdownOp : public Op {
public:
TryShutdownOp(Server *server, Local<Value> server_value) : server(server) {
server_persist.Reset(server_value);
@@ -137,19 +132,17 @@
EscapableHandleScope scope;
return scope.Escape(Nan::New(server_persist));
}
- bool ParseOp(Local<Value> value, grpc_op *out) {
- return true;
- }
- bool IsFinalOp() {
- return false;
- }
+ bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
+ bool IsFinalOp() { return false; }
void OnComplete(bool success) {
if (success) {
server->DestroyWrappedServer();
}
}
+
protected:
std::string GetTypeString() const { return "try_shutdown"; }
+
private:
Server *server;
Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>>
@@ -227,10 +220,9 @@
ops->push_back(unique_ptr<Op>(op));
grpc_call_error error = grpc_server_request_call(
server->wrapped_server, &op->call, &op->details, &op->request_metadata,
- GetCompletionQueue(),
- GetCompletionQueue(),
- new struct tag(new Callback(info[0].As<Function>()), ops.release(),
- NULL, Nan::Null()));
+ GetCompletionQueue(), GetCompletionQueue(),
+ new struct tag(new Callback(info[0].As<Function>()), ops.release(), NULL,
+ Nan::Null()));
if (error != GRPC_CALL_OK) {
return Nan::ThrowError(nanErrorWithCode("requestCall failed", error));
}
diff --git a/src/node/ext/server.h b/src/node/ext/server.h
index c0f2e86..2d8cb4c 100644
--- a/src/node/ext/server.h
+++ b/src/node/ext/server.h
@@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_SERVER_H_
#define NET_GRPC_NODE_SERVER_H_
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
namespace grpc {
diff --git a/src/node/ext/server_credentials.cc b/src/node/ext/server_credentials.cc
index 0ff58bb..e070ff1 100644
--- a/src/node/ext/server_credentials.cc
+++ b/src/node/ext/server_credentials.cc
@@ -78,12 +78,12 @@
tpl->SetClassName(Nan::New("ServerCredentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
Local<Function> ctr = tpl->GetFunction();
- Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
+ Nan::Set(
+ ctr, Nan::New("createSsl").ToLocalChecked(),
+ Nan::GetFunction(Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
- Nan::GetFunction(
- Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked());
+ Nan::GetFunction(Nan::New<FunctionTemplate>(CreateInsecure))
+ .ToLocalChecked());
fun_tpl.Reset(tpl);
constructor = new Nan::Callback(ctr);
Nan::Set(exports, Nan::New("ServerCredentials").ToLocalChecked(), ctr);
@@ -99,9 +99,9 @@
Nan::EscapableHandleScope scope;
const int argc = 1;
Local<Value> argv[argc] = {
- Nan::New<External>(reinterpret_cast<void *>(credentials))};
- MaybeLocal<Object> maybe_instance = Nan::NewInstance(
- constructor->GetFunction(), argc, argv);
+ Nan::New<External>(reinterpret_cast<void *>(credentials))};
+ MaybeLocal<Object> maybe_instance =
+ Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null());
} else {
@@ -160,13 +160,13 @@
}
Local<Array> pair_list = Local<Array>::Cast(info[1]);
uint32_t key_cert_pair_count = pair_list->Length();
- grpc_ssl_pem_key_cert_pair *key_cert_pairs = new grpc_ssl_pem_key_cert_pair[
- key_cert_pair_count];
+ grpc_ssl_pem_key_cert_pair *key_cert_pairs =
+ new grpc_ssl_pem_key_cert_pair[key_cert_pair_count];
Local<String> key_key = Nan::New("private_key").ToLocalChecked();
Local<String> cert_key = Nan::New("cert_chain").ToLocalChecked();
- for(uint32_t i = 0; i < key_cert_pair_count; i++) {
+ for (uint32_t i = 0; i < key_cert_pair_count; i++) {
Local<Value> pair_val = Nan::Get(pair_list, i).ToLocalChecked();
if (!pair_val->IsObject()) {
delete[] key_cert_pairs;
diff --git a/src/node/ext/server_credentials.h b/src/node/ext/server_credentials.h
index bf279e4..808088f 100644
--- a/src/node/ext/server_credentials.h
+++ b/src/node/ext/server_credentials.h
@@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_SERVER_CREDENTIALS_H_
#define NET_GRPC_NODE_SERVER_CREDENTIALS_H_
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
#include "grpc/grpc_security.h"
diff --git a/src/node/ext/server_uv.cc b/src/node/ext/server_uv.cc
index 7899383..709921b 100644
--- a/src/node/ext/server_uv.cc
+++ b/src/node/ext/server_uv.cc
@@ -35,8 +35,8 @@
#include "server.h"
-#include <node.h>
#include <nan.h>
+#include <node.h>
#include "grpc/grpc.h"
#include "grpc/support/time.h"
@@ -60,22 +60,14 @@
class ServerShutdownOp : public Op {
public:
- ServerShutdownOp(grpc_server *server): server(server) {
- }
+ ServerShutdownOp(grpc_server *server) : server(server) {}
- ~ServerShutdownOp() {
- }
+ ~ServerShutdownOp() {}
- Local<Value> GetNodeValue() const {
- return Nan::Null();
- }
+ Local<Value> GetNodeValue() const { return Nan::Null(); }
- bool ParseOp(Local<Value> value, grpc_op *out) {
- return true;
- }
- bool IsFinalOp() {
- return false;
- }
+ bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
+ bool IsFinalOp() { return false; }
void OnComplete(bool success) {
/* Because cancel_all_calls was called, we assume that shutdown_and_notify
completes successfully */
@@ -88,12 +80,9 @@
std::string GetTypeString() const { return "shutdown"; }
};
-Server::Server(grpc_server *server) : wrapped_server(server) {
-}
+Server::Server(grpc_server *server) : wrapped_server(server) {}
-Server::~Server() {
- this->ShutdownServer();
-}
+Server::~Server() { this->ShutdownServer(); }
NAN_METHOD(ServerShutdownCallback) {
if (!info[0]->IsNull()) {
@@ -105,10 +94,10 @@
Nan::HandleScope scope;
if (this->wrapped_server != NULL) {
if (shutdown_callback == NULL) {
- Local<FunctionTemplate>callback_tpl =
+ Local<FunctionTemplate> callback_tpl =
Nan::New<FunctionTemplate>(ServerShutdownCallback);
- shutdown_callback = new Callback(
- Nan::GetFunction(callback_tpl).ToLocalChecked());
+ shutdown_callback =
+ new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
}
ServerShutdownOp *op = new ServerShutdownOp(this->wrapped_server);
diff --git a/src/node/ext/slice.cc b/src/node/ext/slice.cc
index 104dd9e..70e7362 100644
--- a/src/node/ext/slice.cc
+++ b/src/node/ext/slice.cc
@@ -31,10 +31,10 @@
*
*/
-#include <node.h>
-#include <nan.h>
#include <grpc/slice.h>
#include <grpc/support/alloc.h>
+#include <nan.h>
+#include <node.h>
#include "slice.h"
@@ -49,19 +49,19 @@
namespace {
void SliceFreeCallback(char *data, void *hint) {
- grpc_slice *slice = reinterpret_cast<grpc_slice*>(hint);
+ grpc_slice *slice = reinterpret_cast<grpc_slice *>(hint);
grpc_slice_unref(*slice);
delete slice;
}
void string_destroy_func(void *user_data) {
- delete reinterpret_cast<Nan::Utf8String*>(user_data);
+ delete reinterpret_cast<Nan::Utf8String *>(user_data);
}
void buffer_destroy_func(void *user_data) {
- delete reinterpret_cast<PersistentValue*>(user_data);
+ delete reinterpret_cast<PersistentValue *>(user_data);
}
-} // namespace
+} // namespace
grpc_slice CreateSliceFromString(const Local<String> source) {
Nan::HandleScope scope;
@@ -73,28 +73,32 @@
grpc_slice CreateSliceFromBuffer(const Local<Value> source) {
// Prerequisite: ::node::Buffer::HasInstance(source)
Nan::HandleScope scope;
- return grpc_slice_new_with_user_data(::node::Buffer::Data(source),
- ::node::Buffer::Length(source),
- buffer_destroy_func,
- new PersistentValue(source));
+ return grpc_slice_new_with_user_data(
+ ::node::Buffer::Data(source), ::node::Buffer::Length(source),
+ buffer_destroy_func, new PersistentValue(source));
}
Local<String> CopyStringFromSlice(const grpc_slice slice) {
Nan::EscapableHandleScope scope;
if (GRPC_SLICE_LENGTH(slice) == 0) {
return scope.Escape(Nan::EmptyString());
}
- return scope.Escape(Nan::New<String>(
- const_cast<char *>(reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(slice))),
- GRPC_SLICE_LENGTH(slice)).ToLocalChecked());
+ return scope.Escape(
+ Nan::New<String>(const_cast<char *>(reinterpret_cast<const char *>(
+ GRPC_SLICE_START_PTR(slice))),
+ GRPC_SLICE_LENGTH(slice))
+ .ToLocalChecked());
}
Local<Value> CreateBufferFromSlice(const grpc_slice slice) {
Nan::EscapableHandleScope scope;
grpc_slice *slice_ptr = new grpc_slice;
*slice_ptr = grpc_slice_ref(slice);
- return scope.Escape(Nan::NewBuffer(
- const_cast<char *>(reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(*slice_ptr))),
- GRPC_SLICE_LENGTH(*slice_ptr), SliceFreeCallback, slice_ptr).ToLocalChecked());
+ return scope.Escape(
+ Nan::NewBuffer(
+ const_cast<char *>(
+ reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(*slice_ptr))),
+ GRPC_SLICE_LENGTH(*slice_ptr), SliceFreeCallback, slice_ptr)
+ .ToLocalChecked());
}
} // namespace node
diff --git a/src/node/ext/slice.h b/src/node/ext/slice.h
index 7dcb1bd..89c8eca 100644
--- a/src/node/ext/slice.h
+++ b/src/node/ext/slice.h
@@ -31,14 +31,15 @@
*
*/
-#include <node.h>
-#include <nan.h>
#include <grpc/slice.h>
+#include <nan.h>
+#include <node.h>
namespace grpc {
namespace node {
-typedef Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>> PersistentValue;
+typedef Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>>
+ PersistentValue;
grpc_slice CreateSliceFromString(const v8::Local<v8::String> source);
diff --git a/src/node/ext/timeval.cc b/src/node/ext/timeval.cc
index 9284db6..741c324 100644
--- a/src/node/ext/timeval.cc
+++ b/src/node/ext/timeval.cc
@@ -31,8 +31,8 @@
*
*/
-#include <limits>
#include <cstdint>
+#include <limits>
#include "grpc/grpc.h"
#include "grpc/support/time.h"
diff --git a/src/ruby/ext/grpc/rb_byte_buffer.c b/src/ruby/ext/grpc/rb_byte_buffer.c
index 65fa2f2..f5be192 100644
--- a/src/ruby/ext/grpc/rb_byte_buffer.c
+++ b/src/ruby/ext/grpc/rb_byte_buffer.c
@@ -33,15 +33,15 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_byte_buffer.h"
+#include "rb_grpc_imports.generated.h"
-#include <grpc/grpc.h>
#include <grpc/byte_buffer_reader.h>
+#include <grpc/grpc.h>
#include <grpc/slice.h>
#include "rb_grpc.h"
-grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char *string, size_t length) {
+grpc_byte_buffer *grpc_rb_s_to_byte_buffer(char *string, size_t length) {
grpc_slice slice = grpc_slice_from_copied_buffer(string, length);
grpc_byte_buffer *buffer = grpc_raw_byte_buffer_create(&slice, 1);
grpc_slice_unref(slice);
@@ -61,7 +61,7 @@
return Qnil;
}
while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
- rb_str_cat(rb_string, (const char *) GRPC_SLICE_START_PTR(next),
+ rb_str_cat(rb_string, (const char *)GRPC_SLICE_START_PTR(next),
GRPC_SLICE_LENGTH(next));
grpc_slice_unref(next);
}
@@ -71,7 +71,9 @@
VALUE grpc_rb_slice_to_ruby_string(grpc_slice slice) {
if (GRPC_SLICE_START_PTR(slice) == NULL) {
- rb_raise(rb_eRuntimeError, "attempt to convert uninitialized grpc_slice to ruby string");
+ rb_raise(rb_eRuntimeError,
+ "attempt to convert uninitialized grpc_slice to ruby string");
}
- return rb_str_new((char*)GRPC_SLICE_START_PTR(slice), GRPC_SLICE_LENGTH(slice));
+ return rb_str_new((char *)GRPC_SLICE_START_PTR(slice),
+ GRPC_SLICE_LENGTH(slice));
}
diff --git a/src/ruby/ext/grpc/rb_call.c b/src/ruby/ext/grpc/rb_call.c
index 344cb94..aef7175 100644
--- a/src/ruby/ext/grpc/rb_call.c
+++ b/src/ruby/ext/grpc/rb_call.c
@@ -33,12 +33,12 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_call.h"
+#include "rb_grpc_imports.generated.h"
#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/support/alloc.h>
#include "rb_byte_buffer.h"
#include "rb_call_credentials.h"
@@ -113,7 +113,7 @@
if (p == NULL) {
return;
}
- destroy_call((grpc_rb_call*)p);
+ destroy_call((grpc_rb_call *)p);
}
static size_t md_ary_datasize(const void *p) {
@@ -130,7 +130,9 @@
static const rb_data_type_t grpc_rb_md_ary_data_type = {
"grpc_metadata_array",
- {GRPC_RB_GC_NOT_MARKED, GRPC_RB_GC_DONT_FREE, md_ary_datasize,
+ {GRPC_RB_GC_NOT_MARKED,
+ GRPC_RB_GC_DONT_FREE,
+ md_ary_datasize,
{NULL, NULL}},
NULL,
NULL,
@@ -140,19 +142,20 @@
* touches a hash object.
* TODO(yugui) Directly use st_table and call the free function earlier?
*/
- 0,
+ 0,
#endif
};
/* Describes grpc_call struct for RTypedData */
-static const rb_data_type_t grpc_call_data_type = {
- "grpc_call",
- {GRPC_RB_GC_NOT_MARKED, grpc_rb_call_destroy, GRPC_RB_MEMSIZE_UNAVAILABLE,
- {NULL, NULL}},
- NULL,
- NULL,
+static const rb_data_type_t grpc_call_data_type = {"grpc_call",
+ {GRPC_RB_GC_NOT_MARKED,
+ grpc_rb_call_destroy,
+ GRPC_RB_MEMSIZE_UNAVAILABLE,
+ {NULL, NULL}},
+ NULL,
+ NULL,
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
- RUBY_TYPED_FREE_IMMEDIATELY
+ RUBY_TYPED_FREE_IMMEDIATELY
#endif
};
@@ -175,7 +178,7 @@
grpc_rb_call *call = NULL;
grpc_call_error err;
if (RTYPEDDATA_DATA(self) == NULL) {
- //This call has been closed
+ // This call has been closed
return Qnil;
}
@@ -196,7 +199,7 @@
static VALUE grpc_rb_call_close(VALUE self) {
grpc_rb_call *call = NULL;
TypedData_Get_Struct(self, grpc_rb_call, &grpc_call_data_type, call);
- if(call != NULL) {
+ if (call != NULL) {
destroy_call(call);
RTYPEDDATA_DATA(self) = NULL;
}
@@ -238,8 +241,8 @@
}
{
- grpc_auth_property_iterator it =
- grpc_auth_context_find_properties_by_name(ctx, GRPC_X509_PEM_CERT_PROPERTY_NAME);
+ grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
+ ctx, GRPC_X509_PEM_CERT_PROPERTY_NAME);
const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
if (prop == NULL) {
return Qnil;
@@ -388,21 +391,22 @@
long i;
grpc_slice key_slice;
grpc_slice value_slice;
- char* tmp_str;
+ char *tmp_str;
if (TYPE(key) == T_SYMBOL) {
key_slice = grpc_slice_from_static_string(rb_id2name(SYM2ID(key)));
} else if (TYPE(key) == T_STRING) {
- key_slice = grpc_slice_from_copied_buffer(RSTRING_PTR(key), RSTRING_LEN(key));
+ key_slice =
+ grpc_slice_from_copied_buffer(RSTRING_PTR(key), RSTRING_LEN(key));
} else {
- rb_raise(rb_eTypeError, "grpc_rb_md_ary_fill_hash_cb: bad type for key parameter");
+ rb_raise(rb_eTypeError,
+ "grpc_rb_md_ary_fill_hash_cb: bad type for key parameter");
}
if (!grpc_header_key_is_legal(key_slice)) {
tmp_str = grpc_slice_to_c_string(key_slice);
rb_raise(rb_eArgError,
- "'%s' is an invalid header key, must match [a-z0-9-_.]+",
- tmp_str);
+ "'%s' is an invalid header key, must match [a-z0-9-_.]+", tmp_str);
return ST_STOP;
}
@@ -414,13 +418,14 @@
array_length = RARRAY_LEN(val);
/* If the value is an array, add capacity for each value in the array */
for (i = 0; i < array_length; i++) {
- value_slice = grpc_slice_from_copied_buffer(RSTRING_PTR(rb_ary_entry(val, i)), RSTRING_LEN(rb_ary_entry(val, i)));
+ value_slice = grpc_slice_from_copied_buffer(
+ RSTRING_PTR(rb_ary_entry(val, i)), RSTRING_LEN(rb_ary_entry(val, i)));
if (!grpc_is_binary_header(key_slice) &&
!grpc_header_nonbin_value_is_legal(value_slice)) {
// The value has invalid characters
tmp_str = grpc_slice_to_c_string(value_slice);
- rb_raise(rb_eArgError,
- "Header value '%s' has invalid characters", tmp_str);
+ rb_raise(rb_eArgError, "Header value '%s' has invalid characters",
+ tmp_str);
return ST_STOP;
}
md_ary->metadata[md_ary->count].key = key_slice;
@@ -428,21 +433,21 @@
md_ary->count += 1;
}
} else if (TYPE(val) == T_STRING) {
- value_slice = grpc_slice_from_copied_buffer(RSTRING_PTR(val), RSTRING_LEN(val));
+ value_slice =
+ grpc_slice_from_copied_buffer(RSTRING_PTR(val), RSTRING_LEN(val));
if (!grpc_is_binary_header(key_slice) &&
!grpc_header_nonbin_value_is_legal(value_slice)) {
// The value has invalid characters
tmp_str = grpc_slice_to_c_string(value_slice);
- rb_raise(rb_eArgError,
- "Header value '%s' has invalid characters", tmp_str);
+ rb_raise(rb_eArgError, "Header value '%s' has invalid characters",
+ tmp_str);
return ST_STOP;
}
md_ary->metadata[md_ary->count].key = key_slice;
md_ary->metadata[md_ary->count].value = value_slice;
md_ary->count += 1;
} else {
- rb_raise(rb_eArgError,
- "Header values must be of type string or array");
+ rb_raise(rb_eArgError, "Header values must be of type string or array");
return ST_STOP;
}
@@ -474,8 +479,7 @@
/* grpc_rb_md_ary_convert converts a ruby metadata hash into
a grpc_metadata_array.
*/
-void grpc_rb_md_ary_convert(VALUE md_ary_hash,
- grpc_metadata_array *md_ary) {
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary) {
VALUE md_ary_obj = Qnil;
if (md_ary_hash == Qnil) {
return; /* Do nothing if the expected has value is nil */
@@ -511,12 +515,14 @@
rb_hash_aset(result, key, value);
} else if (TYPE(value) == T_ARRAY) {
/* Add the string to the returned array */
- rb_ary_push(value, grpc_rb_slice_to_ruby_string(md_ary->metadata[i].value));
+ rb_ary_push(value,
+ grpc_rb_slice_to_ruby_string(md_ary->metadata[i].value));
} else {
/* Add the current value with this key and the new one to an array */
new_ary = rb_ary_new();
rb_ary_push(new_ary, value);
- rb_ary_push(new_ary, grpc_rb_slice_to_ruby_string(md_ary->metadata[i].value));
+ rb_ary_push(new_ary,
+ grpc_rb_slice_to_ruby_string(md_ary->metadata[i].value));
rb_hash_aset(result, key, new_ary);
}
}
@@ -556,10 +562,9 @@
/* grpc_rb_op_update_status_from_server adds the values in a ruby status
struct to the 'send_status_from_server' portion of an op.
*/
-static void grpc_rb_op_update_status_from_server(grpc_op *op,
- grpc_metadata_array *md_ary,
- grpc_slice *send_status_details,
- VALUE status) {
+static void grpc_rb_op_update_status_from_server(
+ grpc_op *op, grpc_metadata_array *md_ary, grpc_slice *send_status_details,
+ VALUE status) {
VALUE code = rb_struct_aref(status, sym_code);
VALUE details = rb_struct_aref(status, sym_details);
VALUE metadata_hash = rb_struct_aref(status, sym_metadata);
@@ -576,7 +581,8 @@
return;
}
- *send_status_details = grpc_slice_from_copied_buffer(RSTRING_PTR(details), RSTRING_LEN(details));
+ *send_status_details =
+ grpc_slice_from_copied_buffer(RSTRING_PTR(details), RSTRING_LEN(details));
op->data.send_status_from_server.status = NUM2INT(code);
op->data.send_status_from_server.status_details = send_status_details;
@@ -687,7 +693,8 @@
/* N.B. later there is no need to explicitly delete the metadata keys
* and values, they are references to data in ruby objects. */
grpc_rb_op_update_status_from_server(
- &st->ops[st->op_num], &st->send_trailing_metadata, &st->send_status_details, this_value);
+ &st->ops[st->op_num], &st->send_trailing_metadata,
+ &st->send_status_details, this_value);
break;
case GRPC_OP_RECV_INITIAL_METADATA:
st->ops[st->op_num].data.recv_initial_metadata.recv_initial_metadata =
@@ -749,12 +756,12 @@
case GRPC_OP_RECV_STATUS_ON_CLIENT:
rb_struct_aset(
result, sym_status,
- rb_struct_new(grpc_rb_sStatus, UINT2NUM(st->recv_status),
- (GRPC_SLICE_START_PTR(st->recv_status_details) == NULL
- ? Qnil
- : grpc_rb_slice_to_ruby_string(st->recv_status_details)),
- grpc_rb_md_ary_to_h(&st->recv_trailing_metadata),
- NULL));
+ rb_struct_new(
+ grpc_rb_sStatus, UINT2NUM(st->recv_status),
+ (GRPC_SLICE_START_PTR(st->recv_status_details) == NULL
+ ? Qnil
+ : grpc_rb_slice_to_ruby_string(st->recv_status_details)),
+ grpc_rb_md_ary_to_h(&st->recv_trailing_metadata), NULL));
break;
case GRPC_OP_RECV_CLOSE_ON_SERVER:
rb_struct_aset(result, sym_send_close, Qtrue);
@@ -791,7 +798,7 @@
VALUE result = Qnil;
VALUE rb_write_flag = rb_ivar_get(self, id_write_flag);
unsigned write_flag = 0;
- void *tag = (void*)&st;
+ void *tag = (void *)&st;
if (RTYPEDDATA_DATA(self) == NULL) {
rb_raise(grpc_rb_eCallError, "Cannot run batch on closed call");
@@ -919,7 +926,8 @@
}
static void Init_grpc_metadata_keys() {
- VALUE grpc_rb_mMetadataKeys = rb_define_module_under(grpc_rb_mGrpcCore, "MetadataKeys");
+ VALUE grpc_rb_mMetadataKeys =
+ rb_define_module_under(grpc_rb_mGrpcCore, "MetadataKeys");
rb_define_const(grpc_rb_mMetadataKeys, "COMPRESSION_REQUEST_ALGORITHM",
rb_str_new2(GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY));
}
diff --git a/src/ruby/ext/grpc/rb_call.h b/src/ruby/ext/grpc/rb_call.h
index 56becdc..dc597f7 100644
--- a/src/ruby/ext/grpc/rb_call.h
+++ b/src/ruby/ext/grpc/rb_call.h
@@ -39,13 +39,13 @@
#include <grpc/grpc.h>
/* Gets the wrapped call from a VALUE. */
-grpc_call* grpc_rb_get_wrapped_call(VALUE v);
+grpc_call *grpc_rb_get_wrapped_call(VALUE v);
/* Gets the VALUE corresponding to given grpc_call. */
VALUE grpc_rb_wrap_call(grpc_call *c, grpc_completion_queue *q);
/* Provides the details of an call error */
-const char* grpc_call_error_detail_of(grpc_call_error err);
+const char *grpc_call_error_detail_of(grpc_call_error err);
/* Converts a metadata array to a hash. */
VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary);
@@ -53,8 +53,7 @@
/* grpc_rb_md_ary_convert converts a ruby metadata hash into
a grpc_metadata_array.
*/
-void grpc_rb_md_ary_convert(VALUE md_ary_hash,
- grpc_metadata_array *md_ary);
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary);
/* grpc_rb_eCallError is the ruby class of the exception thrown during call
operations. */
diff --git a/src/ruby/ext/grpc/rb_call_credentials.c b/src/ruby/ext/grpc/rb_call_credentials.c
index 280f21c..d654550 100644
--- a/src/ruby/ext/grpc/rb_call_credentials.c
+++ b/src/ruby/ext/grpc/rb_call_credentials.c
@@ -33,8 +33,8 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_call_credentials.h"
+#include "rb_grpc_imports.generated.h"
#include <ruby/thread.h>
@@ -82,20 +82,18 @@
static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
VALUE exception_object) {
VALUE result = rb_hash_new();
- VALUE backtrace = rb_funcall(
- rb_funcall(exception_object, rb_intern("backtrace"), 0),
- rb_intern("join"),
- 1, rb_str_new2("\n\tfrom "));
- VALUE rb_exception_info = rb_funcall(exception_object, rb_intern("inspect"), 0);
+ VALUE backtrace =
+ rb_funcall(rb_funcall(exception_object, rb_intern("backtrace"), 0),
+ rb_intern("join"), 1, rb_str_new2("\n\tfrom "));
+ VALUE rb_exception_info =
+ rb_funcall(exception_object, rb_intern("inspect"), 0);
(void)args;
gpr_log(GPR_INFO, "Call credentials callback failed: %s\n%s",
- StringValueCStr(rb_exception_info),
- StringValueCStr(backtrace));
+ StringValueCStr(rb_exception_info), StringValueCStr(backtrace));
rb_hash_aset(result, rb_str_new2("metadata"), Qnil);
rb_hash_aset(result, rb_str_new2("status"),
INT2NUM(GRPC_STATUS_UNAUTHENTICATED));
- rb_hash_aset(result, rb_str_new2("details"),
- rb_exception_info);
+ rb_hash_aset(result, rb_str_new2("details"), rb_exception_info);
return result;
}
@@ -118,7 +116,8 @@
result = rb_rescue(grpc_rb_call_credentials_callback, callback_args,
grpc_rb_call_credentials_callback_rescue, Qnil);
// Both callbacks return a hash, so result should be a hash
- grpc_rb_md_ary_convert(rb_hash_aref(result, rb_str_new2("metadata")), &md_ary);
+ grpc_rb_md_ary_convert(rb_hash_aref(result, rb_str_new2("metadata")),
+ &md_ary);
status = NUM2INT(rb_hash_aref(result, rb_str_new2("status")));
details = rb_hash_aref(result, rb_str_new2("details"));
error_details = StringValueCStr(details);
@@ -138,7 +137,7 @@
params->callback = cb;
grpc_rb_event_queue_enqueue(grpc_rb_call_credentials_callback_with_gil,
- (void*)(params));
+ (void *)(params));
}
static void grpc_rb_call_credentials_plugin_destroy(void *state) {
@@ -172,13 +171,15 @@
}
static rb_data_type_t grpc_rb_call_credentials_data_type = {
- "grpc_call_credentials",
- {grpc_rb_call_credentials_mark, grpc_rb_call_credentials_free,
- GRPC_RB_MEMSIZE_UNAVAILABLE, {NULL, NULL}},
- NULL,
- NULL,
+ "grpc_call_credentials",
+ {grpc_rb_call_credentials_mark,
+ grpc_rb_call_credentials_free,
+ GRPC_RB_MEMSIZE_UNAVAILABLE,
+ {NULL, NULL}},
+ NULL,
+ NULL,
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
- RUBY_TYPED_FREE_IMMEDIATELY
+ RUBY_TYPED_FREE_IMMEDIATELY
#endif
};
@@ -188,7 +189,8 @@
grpc_rb_call_credentials *wrapper = ALLOC(grpc_rb_call_credentials);
wrapper->wrapped = NULL;
wrapper->mark = Qnil;
- return TypedData_Wrap_Struct(cls, &grpc_rb_call_credentials_data_type, wrapper);
+ return TypedData_Wrap_Struct(cls, &grpc_rb_call_credentials_data_type,
+ wrapper);
}
/* Creates a wrapping object for a given call credentials. This should only be
@@ -230,7 +232,7 @@
rb_raise(rb_eTypeError, "Argument to CallCredentials#new must be a proc");
return Qnil;
}
- plugin.state = (void*)proc;
+ plugin.state = (void *)proc;
plugin.type = "";
creds = grpc_metadata_credentials_create_from_plugin(plugin, NULL);
@@ -289,7 +291,6 @@
grpc_call_credentials *grpc_rb_get_wrapped_call_credentials(VALUE v) {
grpc_rb_call_credentials *wrapper = NULL;
TypedData_Get_Struct(v, grpc_rb_call_credentials,
- &grpc_rb_call_credentials_data_type,
- wrapper);
+ &grpc_rb_call_credentials_data_type, wrapper);
return wrapper->wrapped;
}
diff --git a/src/ruby/ext/grpc/rb_channel.c b/src/ruby/ext/grpc/rb_channel.c
index 05f7160..ecfffd1 100644
--- a/src/ruby/ext/grpc/rb_channel.c
+++ b/src/ruby/ext/grpc/rb_channel.c
@@ -34,9 +34,9 @@
#include <ruby/ruby.h>
#include <ruby/thread.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_byte_buffer.h"
#include "rb_channel.h"
+#include "rb_grpc_imports.generated.h"
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
@@ -196,14 +196,14 @@
gpr_mu_lock(&wrapper->channel_mu);
wrapper->abort_watch_connectivity_state = 0;
- wrapper->current_connectivity_state = grpc_channel_check_connectivity_state(wrapper->wrapped, 0);
+ wrapper->current_connectivity_state =
+ grpc_channel_check_connectivity_state(wrapper->wrapped, 0);
wrapper->safe_to_destroy = 0;
wrapper->request_safe_destroy = 0;
gpr_cv_broadcast(&wrapper->channel_cv);
gpr_mu_unlock(&wrapper->channel_mu);
-
grpc_rb_channel_try_register_connection_polling(wrapper);
if (args.args != NULL) {
@@ -245,7 +245,8 @@
rb_raise(rb_eRuntimeError, "closed!");
return Qnil;
}
- return LONG2NUM(grpc_channel_check_connectivity_state(wrapper->wrapped, grpc_try_to_connect));
+ return LONG2NUM(grpc_channel_check_connectivity_state(wrapper->wrapped,
+ grpc_try_to_connect));
}
typedef struct watch_state_stack {
@@ -255,22 +256,21 @@
} watch_state_stack;
static void *watch_channel_state_without_gvl(void *arg) {
- watch_state_stack *stack = (watch_state_stack*)arg;
+ watch_state_stack *stack = (watch_state_stack *)arg;
gpr_timespec deadline = stack->deadline;
grpc_rb_channel *wrapper = stack->wrapper;
int last_state = stack->last_state;
- void *return_value = (void*)0;
+ void *return_value = (void *)0;
gpr_mu_lock(&wrapper->channel_mu);
- while(wrapper->current_connectivity_state == last_state &&
- !wrapper->request_safe_destroy &&
- !wrapper->safe_to_destroy &&
- !wrapper->abort_watch_connectivity_state &&
- gpr_time_cmp(deadline, gpr_now(GPR_CLOCK_REALTIME)) > 0) {
+ while (wrapper->current_connectivity_state == last_state &&
+ !wrapper->request_safe_destroy && !wrapper->safe_to_destroy &&
+ !wrapper->abort_watch_connectivity_state &&
+ gpr_time_cmp(deadline, gpr_now(GPR_CLOCK_REALTIME)) > 0) {
gpr_cv_wait(&wrapper->channel_cv, &wrapper->channel_mu, deadline);
}
if (wrapper->current_connectivity_state != last_state) {
- return_value = (void*)1;
+ return_value = (void *)1;
}
gpr_mu_unlock(&wrapper->channel_mu);
@@ -278,7 +278,7 @@
}
static void watch_channel_state_unblocking_func(void *arg) {
- grpc_rb_channel *wrapper = (grpc_rb_channel*)arg;
+ grpc_rb_channel *wrapper = (grpc_rb_channel *)arg;
gpr_log(GPR_DEBUG, "GRPC_RUBY: watch channel state unblocking func called");
gpr_mu_lock(&wrapper->channel_mu);
wrapper->abort_watch_connectivity_state = 1;
@@ -298,7 +298,7 @@
VALUE deadline) {
grpc_rb_channel *wrapper = NULL;
watch_state_stack stack;
- void* out;
+ void *out;
TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
@@ -308,14 +308,18 @@
}
if (!FIXNUM_P(last_state)) {
- rb_raise(rb_eTypeError, "bad type for last_state. want a GRPC::Core::ChannelState constant");
+ rb_raise(
+ rb_eTypeError,
+ "bad type for last_state. want a GRPC::Core::ChannelState constant");
return Qnil;
}
stack.wrapper = wrapper;
stack.deadline = grpc_rb_time_timeval(deadline, 0);
stack.last_state = NUM2LONG(last_state);
- out = rb_thread_call_without_gvl(watch_channel_state_without_gvl, &stack, watch_channel_state_unblocking_func, wrapper);
+ out =
+ rb_thread_call_without_gvl(watch_channel_state_without_gvl, &stack,
+ watch_channel_state_unblocking_func, wrapper);
if (out) {
return Qtrue;
}
@@ -420,7 +424,7 @@
// destroy.
// Not safe to call while a channel's connection state is polled.
static void grpc_rb_channel_try_register_connection_polling(
- grpc_rb_channel *wrapper) {
+ grpc_rb_channel *wrapper) {
grpc_connectivity_state conn_state;
gpr_timespec sleep_time = gpr_time_add(
gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_millis(20, GPR_TIMESPAN));
@@ -484,11 +488,14 @@
break;
}
if (event.type == GRPC_OP_COMPLETE) {
- grpc_rb_channel_try_register_connection_polling((grpc_rb_channel *)event.tag);
+ grpc_rb_channel_try_register_connection_polling(
+ (grpc_rb_channel *)event.tag);
}
}
grpc_completion_queue_destroy(channel_polling_cq);
- gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling loop");
+ gpr_log(GPR_DEBUG,
+ "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
+ "loop");
return NULL;
}
@@ -496,7 +503,9 @@
static void grpc_rb_event_unblocking_func(void *arg) {
(void)arg;
gpr_mu_lock(&global_connection_polling_mu);
- gpr_log(GPR_DEBUG, "GRPC_RUBY: grpc_rb_event_unblocking_func - begin aborting connection polling");
+ gpr_log(GPR_DEBUG,
+ "GRPC_RUBY: grpc_rb_event_unblocking_func - begin aborting "
+ "connection polling");
abort_channel_polling = 1;
grpc_completion_queue_shutdown(channel_polling_cq);
gpr_mu_unlock(&global_connection_polling_mu);
@@ -505,7 +514,9 @@
// Poll channel connectivity states in background thread without the GIL.
static VALUE run_poll_channels_loop(VALUE arg) {
(void)arg;
- gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop - create connection polling thread");
+ gpr_log(
+ GPR_DEBUG,
+ "GRPC_RUBY: run_poll_channels_loop - create connection polling thread");
rb_thread_call_without_gvl(run_poll_channels_loop_no_gil, NULL,
grpc_rb_event_unblocking_func, NULL);
return Qnil;
diff --git a/src/ruby/ext/grpc/rb_channel_args.c b/src/ruby/ext/grpc/rb_channel_args.c
index 87c0e0a..fa9ddee 100644
--- a/src/ruby/ext/grpc/rb_channel_args.c
+++ b/src/ruby/ext/grpc/rb_channel_args.c
@@ -33,8 +33,8 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_channel_args.h"
+#include "rb_grpc_imports.generated.h"
#include <grpc/grpc.h>
@@ -42,9 +42,12 @@
static rb_data_type_t grpc_rb_channel_args_data_type = {
"grpc_channel_args",
- {GRPC_RB_GC_NOT_MARKED, GRPC_RB_GC_DONT_FREE, GRPC_RB_MEMSIZE_UNAVAILABLE,
+ {GRPC_RB_GC_NOT_MARKED,
+ GRPC_RB_GC_DONT_FREE,
+ GRPC_RB_MEMSIZE_UNAVAILABLE,
{NULL, NULL}},
- NULL, NULL,
+ NULL,
+ NULL,
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
RUBY_TYPED_FREE_IMMEDIATELY
#endif
@@ -137,11 +140,10 @@
params->dst->num_args = num_args;
params->dst->args = ALLOC_N(grpc_arg, num_args);
MEMZERO(params->dst->args, grpc_arg, num_args);
- rb_hash_foreach(params->src_hash,
- grpc_rb_channel_create_in_process_add_args_hash_cb,
- TypedData_Wrap_Struct(grpc_rb_cChannelArgs,
- &grpc_rb_channel_args_data_type,
- params->dst));
+ rb_hash_foreach(
+ params->src_hash, grpc_rb_channel_create_in_process_add_args_hash_cb,
+ TypedData_Wrap_Struct(grpc_rb_cChannelArgs,
+ &grpc_rb_channel_args_data_type, params->dst));
/* reset num_args as grpc_rb_channel_create_in_process_add_args_hash_cb
* decrements it during has processing */
params->dst->num_args = num_args;
@@ -157,7 +159,7 @@
/* Make a protected call to grpc_rb_hash_convert_channel_args */
params.src_hash = src_hash;
params.dst = dst;
- rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE) & params, &status);
+ rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE)¶ms, &status);
if (status != 0) {
if (dst->args != NULL) {
/* Free any allocated memory before propagating the error */
diff --git a/src/ruby/ext/grpc/rb_channel_credentials.c b/src/ruby/ext/grpc/rb_channel_credentials.c
index 5b7aa34..f30426b 100644
--- a/src/ruby/ext/grpc/rb_channel_credentials.c
+++ b/src/ruby/ext/grpc/rb_channel_credentials.c
@@ -35,8 +35,8 @@
#include <string.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_channel_credentials.h"
+#include "rb_grpc_imports.generated.h"
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
@@ -91,8 +91,10 @@
static rb_data_type_t grpc_rb_channel_credentials_data_type = {
"grpc_channel_credentials",
- {grpc_rb_channel_credentials_mark, grpc_rb_channel_credentials_free,
- GRPC_RB_MEMSIZE_UNAVAILABLE, {NULL, NULL}},
+ {grpc_rb_channel_credentials_mark,
+ grpc_rb_channel_credentials_free,
+ GRPC_RB_MEMSIZE_UNAVAILABLE,
+ {NULL, NULL}},
NULL,
NULL,
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
@@ -106,13 +108,15 @@
grpc_rb_channel_credentials *wrapper = ALLOC(grpc_rb_channel_credentials);
wrapper->wrapped = NULL;
wrapper->mark = Qnil;
- return TypedData_Wrap_Struct(cls, &grpc_rb_channel_credentials_data_type, wrapper);
+ return TypedData_Wrap_Struct(cls, &grpc_rb_channel_credentials_data_type,
+ wrapper);
}
/* Creates a wrapping object for a given channel credentials. This should only
* be called with grpc_channel_credentials objects that are not already
* associated with any Ruby object. */
-VALUE grpc_rb_wrap_channel_credentials(grpc_channel_credentials *c, VALUE mark) {
+VALUE grpc_rb_wrap_channel_credentials(grpc_channel_credentials *c,
+ VALUE mark) {
VALUE rb_wrapper;
grpc_rb_channel_credentials *wrapper;
if (c == NULL) {
@@ -147,7 +151,8 @@
pem_private_key: (optional) PEM encoding of the client's private key
pem_cert_chain: (optional) PEM encoding of the client's cert chain
Initializes Credential instances. */
-static VALUE grpc_rb_channel_credentials_init(int argc, VALUE *argv, VALUE self) {
+static VALUE grpc_rb_channel_credentials_init(int argc, VALUE *argv,
+ VALUE self) {
VALUE pem_root_certs = Qnil;
VALUE pem_private_key = Qnil;
VALUE pem_cert_chain = Qnil;
@@ -170,8 +175,8 @@
} else {
key_cert_pair.private_key = RSTRING_PTR(pem_private_key);
key_cert_pair.cert_chain = RSTRING_PTR(pem_cert_chain);
- creds = grpc_ssl_credentials_create(pem_root_certs_cstr,
- &key_cert_pair, NULL);
+ creds =
+ grpc_ssl_credentials_create(pem_root_certs_cstr, &key_cert_pair, NULL);
}
if (creds == NULL) {
rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
@@ -230,8 +235,8 @@
}
void Init_grpc_channel_credentials() {
- grpc_rb_cChannelCredentials =
- rb_define_class_under(grpc_rb_mGrpcCore, "ChannelCredentials", rb_cObject);
+ grpc_rb_cChannelCredentials = rb_define_class_under(
+ grpc_rb_mGrpcCore, "ChannelCredentials", rb_cObject);
/* Allocates an object managed by the ruby runtime */
rb_define_alloc_func(grpc_rb_cChannelCredentials,
@@ -259,7 +264,6 @@
grpc_channel_credentials *grpc_rb_get_wrapped_channel_credentials(VALUE v) {
grpc_rb_channel_credentials *wrapper = NULL;
TypedData_Get_Struct(v, grpc_rb_channel_credentials,
- &grpc_rb_channel_credentials_data_type,
- wrapper);
+ &grpc_rb_channel_credentials_data_type, wrapper);
return wrapper->wrapped;
}
diff --git a/src/ruby/ext/grpc/rb_completion_queue.c b/src/ruby/ext/grpc/rb_completion_queue.c
index fd75d2f..c9d6773 100644
--- a/src/ruby/ext/grpc/rb_completion_queue.c
+++ b/src/ruby/ext/grpc/rb_completion_queue.c
@@ -33,14 +33,14 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_completion_queue.h"
+#include "rb_grpc_imports.generated.h"
#include <ruby/thread.h>
#include <grpc/grpc.h>
-#include <grpc/support/time.h>
#include <grpc/support/log.h>
+#include <grpc/support/time.h>
#include "rb_grpc.h"
/* Used to allow grpc_completion_queue_next call to release the GIL */
@@ -54,14 +54,13 @@
/* Calls grpc_completion_queue_pluck without holding the ruby GIL */
static void *grpc_rb_completion_queue_pluck_no_gil(void *param) {
- next_call_stack *const next_call = (next_call_stack*)param;
+ next_call_stack *const next_call = (next_call_stack *)param;
gpr_timespec increment = gpr_time_from_millis(20, GPR_TIMESPAN);
gpr_timespec deadline;
do {
deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), increment);
- next_call->event = grpc_completion_queue_pluck(next_call->cq,
- next_call->tag,
- deadline, NULL);
+ next_call->event = grpc_completion_queue_pluck(
+ next_call->cq, next_call->tag, deadline, NULL);
if (next_call->event.type != GRPC_QUEUE_TIMEOUT ||
gpr_time_cmp(deadline, next_call->timeout) > 0) {
break;
@@ -81,7 +80,7 @@
}
static void unblock_func(void *param) {
- next_call_stack *const next_call = (next_call_stack*)param;
+ next_call_stack *const next_call = (next_call_stack *)param;
next_call->interrupted = 1;
}
@@ -111,7 +110,6 @@
(void *)&next_call);
/* If an interrupt prevented pluck from returning useful information, then
any plucks that did complete must have timed out */
- } while (next_call.interrupted &&
- next_call.event.type == GRPC_QUEUE_TIMEOUT);
+ } while (next_call.interrupted && next_call.event.type == GRPC_QUEUE_TIMEOUT);
return next_call.event;
}
diff --git a/src/ruby/ext/grpc/rb_compression_options.c b/src/ruby/ext/grpc/rb_compression_options.c
index 6b2467e..7de3c3c 100644
--- a/src/ruby/ext/grpc/rb_compression_options.c
+++ b/src/ruby/ext/grpc/rb_compression_options.c
@@ -33,15 +33,15 @@
#include <ruby/ruby.h>
-#include "rb_compression_options.h"
#include "rb_byte_buffer.h"
+#include "rb_compression_options.h"
#include "rb_grpc_imports.generated.h"
#include <grpc/compression.h>
#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
#include <grpc/impl/codegen/compression_types.h>
#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/alloc.h>
#include <string.h>
#include "rb_grpc.h"
@@ -179,15 +179,16 @@
* correct C string out of it. */
algorithm_name_as_string = rb_funcall(algorithm_name, rb_intern("to_s"), 0);
- name_slice = grpc_slice_from_copied_buffer(RSTRING_PTR(algorithm_name_as_string), RSTRING_LEN(algorithm_name_as_string));
+ name_slice =
+ grpc_slice_from_copied_buffer(RSTRING_PTR(algorithm_name_as_string),
+ RSTRING_LEN(algorithm_name_as_string));
/* Raise an error if the name isn't recognized as a compression algorithm by
* the algorithm parse function
* in GRPC core. */
- if(!grpc_compression_algorithm_parse(name_slice, algorithm_value)) {
+ if (!grpc_compression_algorithm_parse(name_slice, algorithm_value)) {
tmp_str = grpc_slice_to_c_string(name_slice);
- rb_raise(rb_eNameError, "Invalid compression algorithm name: %s",
- tmp_str);
+ rb_raise(rb_eNameError, "Invalid compression algorithm name: %s", tmp_str);
}
grpc_slice_unref(name_slice);
diff --git a/src/ruby/ext/grpc/rb_event_thread.c b/src/ruby/ext/grpc/rb_event_thread.c
index 9e85bbc..9a3b56d 100644
--- a/src/ruby/ext/grpc/rb_event_thread.c
+++ b/src/ruby/ext/grpc/rb_event_thread.c
@@ -33,20 +33,20 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_event_thread.h"
+#include "rb_grpc_imports.generated.h"
#include <stdbool.h>
-#include <ruby/thread.h>
#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
#include <grpc/support/sync.h>
#include <grpc/support/time.h>
-#include <grpc/support/log.h>
+#include <ruby/thread.h>
typedef struct grpc_rb_event {
// callback will be called with argument while holding the GVL
- void (*callback)(void*);
+ void (*callback)(void *);
void *argument;
struct grpc_rb_event *next;
@@ -65,8 +65,7 @@
static grpc_rb_event_queue event_queue;
-void grpc_rb_event_queue_enqueue(void (*callback)(void*),
- void *argument) {
+void grpc_rb_event_queue_enqueue(void (*callback)(void *), void *argument) {
grpc_rb_event *event = gpr_malloc(sizeof(grpc_rb_event));
event->callback = callback;
event->argument = argument;
@@ -107,8 +106,7 @@
(void)param;
gpr_mu_lock(&event_queue.mu);
while ((event = grpc_rb_event_queue_dequeue()) == NULL) {
- gpr_cv_wait(&event_queue.cv,
- &event_queue.mu,
+ gpr_cv_wait(&event_queue.cv, &event_queue.mu,
gpr_inf_future(GPR_CLOCK_REALTIME));
if (event_queue.abort) {
gpr_mu_unlock(&event_queue.mu);
@@ -132,10 +130,10 @@
static VALUE grpc_rb_event_thread(VALUE arg) {
grpc_rb_event *event;
(void)arg;
- while(true) {
- event = (grpc_rb_event*)rb_thread_call_without_gvl(
- grpc_rb_wait_for_event_no_gil, NULL,
- grpc_rb_event_unblocking_func, NULL);
+ while (true) {
+ event = (grpc_rb_event *)rb_thread_call_without_gvl(
+ grpc_rb_wait_for_event_no_gil, NULL, grpc_rb_event_unblocking_func,
+ NULL);
if (event == NULL) {
// Indicates that the thread needs to shut down
break;
diff --git a/src/ruby/ext/grpc/rb_event_thread.h b/src/ruby/ext/grpc/rb_event_thread.h
index 46638bf..d7eff76 100644
--- a/src/ruby/ext/grpc/rb_event_thread.h
+++ b/src/ruby/ext/grpc/rb_event_thread.h
@@ -33,5 +33,4 @@
void grpc_rb_event_queue_thread_start();
-void grpc_rb_event_queue_enqueue(void (*callback)(void*),
- void *argument);
+void grpc_rb_event_queue_enqueue(void (*callback)(void *), void *argument);
diff --git a/src/ruby/ext/grpc/rb_grpc.c b/src/ruby/ext/grpc/rb_grpc.c
index 17cd165..d45a5ea 100644
--- a/src/ruby/ext/grpc/rb_grpc.c
+++ b/src/ruby/ext/grpc/rb_grpc.c
@@ -33,8 +33,8 @@
#include <ruby/ruby.h>
-#include "rb_grpc_imports.generated.h"
#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
#include <math.h>
#include <ruby/vm.h>
@@ -46,16 +46,18 @@
#include "rb_call_credentials.h"
#include "rb_channel.h"
#include "rb_channel_credentials.h"
+#include "rb_compression_options.h"
#include "rb_loader.h"
#include "rb_server.h"
#include "rb_server_credentials.h"
-#include "rb_compression_options.h"
static VALUE grpc_rb_cTimeVal = Qnil;
static rb_data_type_t grpc_rb_timespec_data_type = {
"gpr_timespec",
- {GRPC_RB_GC_NOT_MARKED, GRPC_RB_GC_DONT_FREE, GRPC_RB_MEMSIZE_UNAVAILABLE,
+ {GRPC_RB_GC_NOT_MARKED,
+ GRPC_RB_GC_DONT_FREE,
+ GRPC_RB_MEMSIZE_UNAVAILABLE,
{NULL, NULL}},
NULL,
NULL,
@@ -84,8 +86,7 @@
/* Init/Clone func that fails by raising an exception. */
VALUE grpc_rb_cannot_init_copy(VALUE copy, VALUE self) {
(void)self;
- rb_raise(rb_eTypeError,
- "Copy initialization of %s is not supported",
+ rb_raise(rb_eTypeError, "Copy initialization of %s is not supported",
rb_obj_classname(copy));
return Qnil;
}
@@ -143,8 +144,7 @@
}
t.tv_sec = (int64_t)f;
if (f != t.tv_sec) {
- rb_raise(rb_eRangeError, "%f out of Time range",
- RFLOAT_VALUE(time));
+ rb_raise(rb_eRangeError, "%f out of Time range", RFLOAT_VALUE(time));
}
t.tv_nsec = (int)(d * 1e9 + 0.5);
}
@@ -269,9 +269,7 @@
id_tv_nsec = rb_intern("tv_nsec");
}
-static void grpc_rb_shutdown(void) {
- grpc_shutdown();
-}
+static void grpc_rb_shutdown(void) { grpc_shutdown(); }
/* Initialize the GRPC module structs */
@@ -316,9 +314,8 @@
grpc_rb_mGRPC = rb_define_module("GRPC");
grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core");
- grpc_rb_sNewServerRpc =
- rb_struct_define("NewServerRpc", "method", "host",
- "deadline", "metadata", "call", NULL);
+ grpc_rb_sNewServerRpc = rb_struct_define(
+ "NewServerRpc", "method", "host", "deadline", "metadata", "call", NULL);
grpc_rb_sStatus =
rb_struct_define("Status", "code", "details", "metadata", NULL);
sym_code = ID2SYM(rb_intern("code"));
diff --git a/src/ruby/ext/grpc/rb_grpc.h b/src/ruby/ext/grpc/rb_grpc.h
index 6ea6cbd..2ee1faa 100644
--- a/src/ruby/ext/grpc/rb_grpc.h
+++ b/src/ruby/ext/grpc/rb_grpc.h
@@ -34,8 +34,8 @@
#ifndef GRPC_RB_H_
#define GRPC_RB_H_
-#include <sys/time.h>
#include <ruby/ruby.h>
+#include <sys/time.h>
#include <grpc/support/time.h>
@@ -68,7 +68,7 @@
/* GRPC_RB_MEMSIZE_UNAVAILABLE is used in rb_data_type_t to indicate that the
* number of bytes used by the wrapped struct is not available. */
-#define GRPC_RB_MEMSIZE_UNAVAILABLE (size_t (*)(const void*))(NULL)
+#define GRPC_RB_MEMSIZE_UNAVAILABLE (size_t(*)(const void*))(NULL)
/* A ruby object alloc func that fails by raising an exception. */
VALUE grpc_rb_cannot_alloc(VALUE cls);