void test_connect(const char *server_host, const char *client_host, int port, int expect_ok) { char *client_hostport; char *server_hostport; grpc_channel *client; grpc_server *server; grpc_completion_queue *client_cq; grpc_completion_queue *server_cq; grpc_call *c; grpc_call *s; cq_verifier *v_client; cq_verifier *v_server; gpr_timespec deadline; int got_port; if (port == 0) { port = grpc_pick_unused_port_or_die(); } gpr_join_host_port(&server_hostport, server_host, port); /* Create server. */ server_cq = grpc_completion_queue_create(); server = grpc_server_create(server_cq, NULL); GPR_ASSERT((got_port = grpc_server_add_http2_port(server, server_hostport)) > 0); if (port == 0) { port = got_port; } else { GPR_ASSERT(port == got_port); } grpc_server_start(server); v_server = cq_verifier_create(server_cq); /* Create client. */ gpr_join_host_port(&client_hostport, client_host, port); client_cq = grpc_completion_queue_create(); client = grpc_channel_create(client_hostport, NULL); v_client = cq_verifier_create(client_cq); gpr_log(GPR_INFO, "Testing with server=%s client=%s (expecting %s)", server_hostport, client_hostport, expect_ok ? "success" : "failure"); gpr_free(client_hostport); gpr_free(server_hostport); if (expect_ok) { /* Normal deadline, shouldn't be reached. */ deadline = ms_from_now(60000); } else { /* Give up faster when failure is expected. BUG: Setting this to 1000 reveals a memory leak (b/18608927). */ deadline = ms_from_now(1500); } /* Send a trivial request. */ c = grpc_channel_create_call_old(client, "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); GPR_ASSERT(GRPC_CALL_OK == grpc_call_invoke_old(c, client_cq, tag(2), tag(3), 0)); GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); if (expect_ok) { /* Check for a successful request. */ cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK); cq_verify(v_client); GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(server, tag(100))); cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "foo.test.google.fr", deadline, NULL); cq_verify(v_server); GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_accept_old(s, server_cq, tag(102))); GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_end_initial_metadata_old(s, 0)); cq_expect_client_metadata_read(v_client, tag(2), NULL); cq_verify(v_client); GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old(s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(5))); cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_UNIMPLEMENTED, "xyz", NULL); cq_verify(v_client); cq_expect_finish_accepted(v_server, tag(5), GRPC_OP_OK); cq_expect_finished(v_server, tag(102), NULL); cq_verify(v_server); grpc_call_destroy(c); grpc_call_destroy(s); } else { /* Check for a failed connection. */ cq_expect_client_metadata_read(v_client, tag(2), NULL); cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_DEADLINE_EXCEEDED, "Deadline Exceeded", NULL); cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_ERROR); cq_verify(v_client); grpc_call_destroy(c); } cq_verifier_destroy(v_client); cq_verifier_destroy(v_server); /* Destroy client. */ grpc_channel_destroy(client); grpc_completion_queue_shutdown(client_cq); drain_cq(client_cq); grpc_completion_queue_destroy(client_cq); /* Destroy server. */ grpc_server_shutdown(server); grpc_server_destroy(server); grpc_completion_queue_shutdown(server_cq); drain_cq(server_cq); grpc_completion_queue_destroy(server_cq); }
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { grpc_test_only_set_metadata_hash_seed(0); struct grpc_memory_counters counters; if (squelch) gpr_set_log_function(dont_log); if (leak_check) grpc_memory_counters_init(); grpc_init(); grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_resource_quota *resource_quota = grpc_resource_quota_create("server_fuzzer"); grpc_endpoint *mock_endpoint = grpc_mock_endpoint_create(discard_write, resource_quota); grpc_resource_quota_internal_unref(&exec_ctx, resource_quota); grpc_mock_endpoint_put_read( &exec_ctx, mock_endpoint, gpr_slice_from_copied_buffer((const char *)data, size)); grpc_server *server = grpc_server_create(NULL, NULL); grpc_completion_queue *cq = grpc_completion_queue_create(NULL); grpc_server_register_completion_queue(server, cq, NULL); // TODO(ctiller): add registered methods (one for POST, one for PUT) // void *registered_method = // grpc_server_register_method(server, "/reg", NULL, 0); grpc_server_start(server); grpc_transport *transport = grpc_create_chttp2_transport(&exec_ctx, NULL, mock_endpoint, 0); grpc_server_setup_transport(&exec_ctx, server, transport, NULL, NULL); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL); grpc_call *call1 = NULL; grpc_call_details call_details1; grpc_metadata_array request_metadata1; grpc_call_details_init(&call_details1); grpc_metadata_array_init(&request_metadata1); int requested_calls = 0; grpc_server_request_call(server, &call1, &call_details1, &request_metadata1, cq, cq, tag(1)); requested_calls++; grpc_event ev; while (1) { grpc_exec_ctx_flush(&exec_ctx); ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL); switch (ev.type) { case GRPC_QUEUE_TIMEOUT: goto done; case GRPC_QUEUE_SHUTDOWN: break; case GRPC_OP_COMPLETE: switch (detag(ev.tag)) { case 1: requested_calls--; // TODO(ctiller): keep reading that call! break; } } } done: if (call1 != NULL) grpc_call_destroy(call1); grpc_call_details_destroy(&call_details1); grpc_metadata_array_destroy(&request_metadata1); grpc_server_shutdown_and_notify(server, cq, tag(0xdead)); grpc_server_cancel_all_calls(server); for (int i = 0; i <= requested_calls; i++) { ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL); GPR_ASSERT(ev.type == GRPC_OP_COMPLETE); } grpc_completion_queue_shutdown(cq); for (int i = 0; i <= requested_calls; i++) { ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), NULL); GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN); } grpc_server_destroy(server); grpc_completion_queue_destroy(cq); grpc_shutdown(); if (leak_check) { counters = grpc_memory_counters_snapshot(); grpc_memory_counters_destroy(); GPR_ASSERT(counters.total_size_relative == 0); } return 0; }
int main(int argc, char **argv) { grpc_channel *chan; grpc_call *call; gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(2); grpc_completion_queue *cq; cq_verifier *cqv; grpc_op ops[6]; grpc_op *op; grpc_metadata_array trailing_metadata_recv; grpc_status_code status; char *details = NULL; size_t details_capacity = 0; grpc_test_init(argc, argv); grpc_init(); grpc_metadata_array_init(&trailing_metadata_recv); cq = grpc_completion_queue_create(NULL); cqv = cq_verifier_create(cq); /* create a call, channel to a non existant server */ chan = grpc_insecure_channel_create("nonexistant:54321", NULL, NULL); call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/Foo", "nonexistant", deadline, NULL); memset(ops, 0, sizeof(ops)); op = ops; op->op = GRPC_OP_SEND_INITIAL_METADATA; op->data.send_initial_metadata.count = 0; op->flags = 0; op->reserved = NULL; op++; op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; op->data.recv_status_on_client.status = &status; op->data.recv_status_on_client.status_details = &details; op->data.recv_status_on_client.status_details_capacity = &details_capacity; op->flags = 0; op->reserved = NULL; op++; GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch( call, ops, (size_t)(op - ops), tag(1), NULL)); /* verify that all tags get completed */ cq_expect_completion(cqv, tag(1), 1); cq_verify(cqv); GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED); grpc_completion_queue_shutdown(cq); while ( grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL) .type != GRPC_QUEUE_SHUTDOWN) ; grpc_completion_queue_destroy(cq); grpc_call_destroy(call); grpc_channel_destroy(chan); cq_verifier_destroy(cqv); gpr_free(details); grpc_metadata_array_destroy(&trailing_metadata_recv); grpc_shutdown(); return 0; }
static void shutdown_complete(void *arg, int success) { grpc_end2end_proxy *proxy = arg; proxy->shutdown = 1; grpc_completion_queue_shutdown(proxy->cq); }
int main(int argc, char **argv) { grpc_event ev; call_state *s; char *addr_buf = NULL; gpr_cmdline *cl; int shutdown_started = 0; int shutdown_finished = 0; int secure = 0; char *addr = NULL; char *fake_argv[1]; gpr_timers_set_log_filename("latency_trace.fling_server.txt"); GPR_ASSERT(argc >= 1); fake_argv[0] = argv[0]; grpc_test_init(1, fake_argv); grpc_init(); srand((unsigned)clock()); cl = gpr_cmdline_create("fling server"); gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr); gpr_cmdline_add_flag(cl, "secure", "Run with security?", &secure); gpr_cmdline_parse(cl, argc, argv); gpr_cmdline_destroy(cl); if (addr == NULL) { gpr_join_host_port(&addr_buf, "::", grpc_pick_unused_port_or_die()); addr = addr_buf; } gpr_log(GPR_INFO, "creating server on: %s", addr); cq = grpc_completion_queue_create(NULL); if (secure) { grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key, test_server1_cert}; grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create( NULL, &pem_key_cert_pair, 1, 0, NULL); server = grpc_server_create(NULL, NULL); GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds)); grpc_server_credentials_release(ssl_creds); } else { server = grpc_server_create(NULL, NULL); GPR_ASSERT(grpc_server_add_insecure_http2_port(server, addr)); } grpc_server_register_completion_queue(server, cq, NULL); grpc_server_start(server); gpr_free(addr_buf); addr = addr_buf = NULL; grpc_call_details_init(&call_details); request_call(); grpc_profiler_start("server.prof"); signal(SIGINT, sigint_handler); while (!shutdown_finished) { if (got_sigint && !shutdown_started) { gpr_log(GPR_INFO, "Shutting down due to SIGINT"); grpc_server_shutdown_and_notify(server, cq, tag(1000)); GPR_ASSERT(grpc_completion_queue_pluck( cq, tag(1000), GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), NULL) .type == GRPC_OP_COMPLETE); grpc_completion_queue_shutdown(cq); shutdown_started = 1; } ev = grpc_completion_queue_next( cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_micros(1000000, GPR_TIMESPAN)), NULL); s = ev.tag; switch (ev.type) { case GRPC_OP_COMPLETE: switch ((intptr_t)s) { case FLING_SERVER_NEW_REQUEST: if (call != NULL) { if (0 == strcmp(call_details.method, "/Reflector/reflectStream")) { /* Received streaming call. Send metadata here. */ start_read_op(FLING_SERVER_READ_FOR_STREAMING); send_initial_metadata(); } else { /* Received unary call. Can do all ops in one batch. */ start_read_op(FLING_SERVER_READ_FOR_UNARY); } } else { GPR_ASSERT(shutdown_started); } /* request_call(); */ break; case FLING_SERVER_READ_FOR_STREAMING: if (payload_buffer != NULL) { /* Received payload from client. */ start_write_op(); } else { /* Received end of stream from client. */ start_send_status(); } break; case FLING_SERVER_WRITE_FOR_STREAMING: /* Write completed at server */ grpc_byte_buffer_destroy(payload_buffer); payload_buffer = NULL; start_read_op(FLING_SERVER_READ_FOR_STREAMING); break; case FLING_SERVER_SEND_INIT_METADATA_FOR_STREAMING: /* Metadata send completed at server */ break; case FLING_SERVER_SEND_STATUS_FOR_STREAMING: /* Send status and close completed at server */ grpc_call_destroy(call); if (!shutdown_started) request_call(); break; case FLING_SERVER_READ_FOR_UNARY: /* Finished payload read for unary. Start all reamaining * unary ops in a batch. */ handle_unary_method(); break; case FLING_SERVER_BATCH_OPS_FOR_UNARY: /* Finished unary call. */ grpc_byte_buffer_destroy(payload_buffer); payload_buffer = NULL; grpc_call_destroy(call); if (!shutdown_started) request_call(); break; } break; case GRPC_QUEUE_SHUTDOWN: GPR_ASSERT(shutdown_started); shutdown_finished = 1; break; case GRPC_QUEUE_TIMEOUT: break; } } grpc_profiler_stop(); grpc_call_details_destroy(&call_details); grpc_server_destroy(server); grpc_completion_queue_destroy(cq); grpc_shutdown(); return 0; }