Yang Gao
10 years ago
commit
ea13af73e0
96 changed files with 3522 additions and 16326 deletions
@ -0,0 +1,6 @@ |
||||
provider _stap { |
||||
probe add_mark(int tag); |
||||
probe timing_ns_begin(int tag); |
||||
probe timing_ns_end(int tag); |
||||
}; |
||||
|
||||
@ -0,0 +1,57 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#ifdef GRPC_STAP_PROFILER |
||||
|
||||
#include "src/core/profiling/timers.h" |
||||
|
||||
#include <sys/sdt.h> |
||||
/* Generated from src/core/profiling/stap_probes.d */ |
||||
#include "src/core/profiling/stap_probes.h" |
||||
|
||||
/* Latency profiler API implementation. */ |
||||
void grpc_timer_add_mark(int tag, void* id, const char *file, int line) { |
||||
_STAP_ADD_MARK(tag); |
||||
} |
||||
|
||||
void grpc_timer_begin(int tag, void* id, const char *file, int line) { |
||||
_STAP_TIMING_NS_BEGIN(tag); |
||||
} |
||||
|
||||
void grpc_timer_end(int tag, void* id, const char *file, int line) { |
||||
_STAP_TIMING_NS_END(tag); |
||||
} |
||||
|
||||
#endif /* GRPC_STAP_PROFILER */ |
||||
@ -0,0 +1,42 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <sys/sdt.h> |
||||
|
||||
#ifndef _SYS_SDT_H |
||||
#error "_SYS_SDT_H not defined, despite <sys/sdt.h> being present." |
||||
#endif |
||||
|
||||
int main() { |
||||
return 0; |
||||
} |
||||
@ -1,138 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/grpc.h> |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/byte_buffer.h> |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
enum { WRITE_SLICE_LENGTH = 1024, TOTAL_BYTES = 102400 }; |
||||
|
||||
/* Start write the next slice, fill slice.data[0..length - 1] with first % 256,
|
||||
(first + 1) % 256, ... (first + length - 1) % 256. |
||||
Produce a GRPC_WRITE_ACCEPTED event */ |
||||
static void start_write_next_slice(grpc_call *call, int first, int length) { |
||||
int i = 0; |
||||
grpc_byte_buffer *byte_buffer = NULL; |
||||
gpr_slice slice = gpr_slice_malloc(length); |
||||
for (i = 0; i < length; i++) |
||||
GPR_SLICE_START_PTR(slice)[i] = (first + i) % 256; |
||||
byte_buffer = grpc_byte_buffer_create(&slice, 1); |
||||
GPR_ASSERT(grpc_call_start_write_old(call, byte_buffer, (void *)1, 0) == |
||||
GRPC_CALL_OK); |
||||
gpr_slice_unref(slice); |
||||
grpc_byte_buffer_destroy(byte_buffer); |
||||
} |
||||
|
||||
int main(int argc, char **argv) { |
||||
grpc_channel *channel = NULL; |
||||
grpc_call *call = NULL; |
||||
grpc_event *ev = NULL; |
||||
grpc_byte_buffer_reader *bb_reader = NULL; |
||||
grpc_completion_queue *cq = NULL; |
||||
int bytes_written = 0; |
||||
int bytes_read = 0; |
||||
unsigned i = 0; |
||||
int waiting_finishes; |
||||
gpr_slice read_slice; |
||||
|
||||
grpc_test_init(argc, argv); |
||||
|
||||
grpc_init(); |
||||
|
||||
cq = grpc_completion_queue_create(); |
||||
|
||||
GPR_ASSERT(argc == 2); |
||||
channel = grpc_channel_create(argv[1], NULL); |
||||
call = grpc_channel_create_call_old(channel, "/foo", "localhost", |
||||
GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5)); |
||||
GPR_ASSERT(grpc_call_invoke_old(call, cq, (void *)1, (void *)1, 0) == |
||||
GRPC_CALL_OK); |
||||
|
||||
start_write_next_slice(call, bytes_written, WRITE_SLICE_LENGTH); |
||||
bytes_written += WRITE_SLICE_LENGTH; |
||||
GPR_ASSERT(grpc_call_start_read_old(call, (void *)1) == GRPC_CALL_OK); |
||||
waiting_finishes = 2; |
||||
while (waiting_finishes) { |
||||
ev = grpc_completion_queue_next(cq, gpr_inf_future); |
||||
switch (ev->type) { |
||||
case GRPC_WRITE_ACCEPTED: |
||||
if (bytes_written < TOTAL_BYTES) { |
||||
start_write_next_slice(call, bytes_written, WRITE_SLICE_LENGTH); |
||||
bytes_written += WRITE_SLICE_LENGTH; |
||||
} else { |
||||
GPR_ASSERT(grpc_call_writes_done_old(call, (void *)1) == |
||||
GRPC_CALL_OK); |
||||
} |
||||
break; |
||||
case GRPC_CLIENT_METADATA_READ: |
||||
break; |
||||
case GRPC_READ: |
||||
bb_reader = grpc_byte_buffer_reader_create(ev->data.read); |
||||
while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) { |
||||
for (i = 0; i < GPR_SLICE_LENGTH(read_slice); i++) { |
||||
GPR_ASSERT(GPR_SLICE_START_PTR(read_slice)[i] == bytes_read % 256); |
||||
bytes_read++; |
||||
} |
||||
gpr_slice_unref(read_slice); |
||||
} |
||||
grpc_byte_buffer_reader_destroy(bb_reader); |
||||
if (bytes_read < TOTAL_BYTES) { |
||||
GPR_ASSERT(grpc_call_start_read_old(call, (void *)1) == GRPC_CALL_OK); |
||||
} |
||||
break; |
||||
case GRPC_FINISHED: |
||||
case GRPC_FINISH_ACCEPTED: |
||||
waiting_finishes--; |
||||
break; |
||||
default: |
||||
GPR_ASSERT(0 && "unexpected event"); |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
GPR_ASSERT(bytes_read == TOTAL_BYTES); |
||||
gpr_log(GPR_INFO, "All data have been successfully echoed"); |
||||
|
||||
grpc_call_destroy(call); |
||||
grpc_channel_destroy(channel); |
||||
grpc_completion_queue_destroy(cq); |
||||
|
||||
grpc_shutdown(); |
||||
|
||||
return 0; |
||||
} |
||||
@ -1,135 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef _POSIX_SOURCE |
||||
#define _POSIX_SOURCE |
||||
#endif |
||||
|
||||
#include <unistd.h> |
||||
#include <assert.h> |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <signal.h> |
||||
#include <stdlib.h> |
||||
#include <sys/types.h> |
||||
#include <sys/wait.h> |
||||
|
||||
#include "src/core/iomgr/socket_utils_posix.h" |
||||
#include "src/core/support/string.h" |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/host_port.h> |
||||
#include <grpc/support/log.h> |
||||
#include "test/core/util/port.h" |
||||
|
||||
int test_client(const char *root, const char *host, int port) { |
||||
int status; |
||||
pid_t cli; |
||||
cli = fork(); |
||||
if (cli == 0) { |
||||
char *binary_path; |
||||
char *binding; |
||||
gpr_asprintf(&binary_path, "%s/echo_client", root); |
||||
gpr_join_host_port(&binding, host, port); |
||||
|
||||
execl(binary_path, binary_path, binding, NULL); |
||||
|
||||
gpr_free(binary_path); |
||||
gpr_free(binding); |
||||
return 1; |
||||
} |
||||
/* wait for client */ |
||||
gpr_log(GPR_INFO, "Waiting for client: %s", host); |
||||
if (waitpid(cli, &status, 0) == -1) return 2; |
||||
if (!WIFEXITED(status)) return 4; |
||||
if (WEXITSTATUS(status)) return WEXITSTATUS(status); |
||||
return 0; |
||||
} |
||||
|
||||
int main(int argc, char **argv) { |
||||
char *me = argv[0]; |
||||
char *lslash = strrchr(me, '/'); |
||||
char root[1024]; |
||||
int port = grpc_pick_unused_port_or_die(); |
||||
int status; |
||||
pid_t svr; |
||||
int ret; |
||||
int do_ipv6 = 1; |
||||
/* seed rng with pid, so we don't end up with the same random numbers as a
|
||||
concurrently running test binary */ |
||||
srand(getpid()); |
||||
if (!grpc_ipv6_loopback_available()) { |
||||
gpr_log(GPR_INFO, "Can't bind to ::1. Skipping IPv6 tests."); |
||||
do_ipv6 = 0; |
||||
} |
||||
/* figure out where we are */ |
||||
if (lslash) { |
||||
memcpy(root, me, lslash - me); |
||||
root[lslash - me] = 0; |
||||
} else { |
||||
strcpy(root, "."); |
||||
} |
||||
/* start the server */ |
||||
svr = fork(); |
||||
if (svr == 0) { |
||||
char *binary_path; |
||||
char *binding; |
||||
gpr_asprintf(&binary_path, "%s/echo_server", root); |
||||
gpr_join_host_port(&binding, "::", port); |
||||
|
||||
execl(binary_path, binary_path, "-bind", binding, NULL); |
||||
|
||||
gpr_free(binary_path); |
||||
gpr_free(binding); |
||||
return 1; |
||||
} |
||||
/* wait a little */ |
||||
sleep(2); |
||||
/* start the clients */ |
||||
ret = test_client(root, "127.0.0.1", port); |
||||
if (ret != 0) return ret; |
||||
ret = test_client(root, "::ffff:127.0.0.1", port); |
||||
if (ret != 0) return ret; |
||||
ret = test_client(root, "localhost", port); |
||||
if (ret != 0) return ret; |
||||
if (do_ipv6) { |
||||
ret = test_client(root, "::1", port); |
||||
if (ret != 0) return ret; |
||||
} |
||||
/* wait for server */ |
||||
gpr_log(GPR_INFO, "Waiting for server"); |
||||
kill(svr, SIGINT); |
||||
if (waitpid(svr, &status, 0) == -1) return 2; |
||||
if (!WIFEXITED(status)) return 4; |
||||
if (WEXITSTATUS(status)) return WEXITSTATUS(status); |
||||
return 0; |
||||
} |
||||
@ -1,223 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/grpc.h> |
||||
#include <grpc/grpc_http.h> |
||||
#include <grpc/grpc_security.h> |
||||
|
||||
#include <signal.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <time.h> |
||||
|
||||
#include "src/core/support/string.h" |
||||
#include "test/core/util/test_config.h" |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/cmdline.h> |
||||
#include <grpc/support/host_port.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include "test/core/util/port.h" |
||||
#include "test/core/end2end/data/ssl_test_data.h" |
||||
|
||||
static grpc_completion_queue *cq; |
||||
static grpc_server *server; |
||||
static int got_sigint = 0; |
||||
|
||||
typedef struct { |
||||
gpr_refcount pending_ops; |
||||
gpr_intmax bytes_read; |
||||
} call_state; |
||||
|
||||
static void request_call(void) { |
||||
call_state *tag = gpr_malloc(sizeof(*tag)); |
||||
gpr_ref_init(&tag->pending_ops, 2); |
||||
tag->bytes_read = 0; |
||||
grpc_server_request_call_old(server, tag); |
||||
} |
||||
|
||||
static void assert_read_ok(call_state *s, grpc_byte_buffer *b) { |
||||
grpc_byte_buffer_reader *bb_reader = NULL; |
||||
gpr_slice read_slice; |
||||
unsigned i; |
||||
|
||||
bb_reader = grpc_byte_buffer_reader_create(b); |
||||
while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) { |
||||
for (i = 0; i < GPR_SLICE_LENGTH(read_slice); i++) { |
||||
GPR_ASSERT(GPR_SLICE_START_PTR(read_slice)[i] == s->bytes_read % 256); |
||||
s->bytes_read++; |
||||
} |
||||
gpr_slice_unref(read_slice); |
||||
} |
||||
grpc_byte_buffer_reader_destroy(bb_reader); |
||||
} |
||||
|
||||
static void sigint_handler(int x) { got_sigint = 1; } |
||||
|
||||
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]; |
||||
|
||||
#define MAX_ARGS 4 |
||||
grpc_arg arge[MAX_ARGS]; |
||||
grpc_arg *e; |
||||
grpc_channel_args args = {0, NULL}; |
||||
|
||||
grpc_http_server_page home_page = {"/", "text/html", |
||||
"<head>\n" |
||||
"<title>Echo Server</title>\n" |
||||
"</head>\n" |
||||
"<body>\n" |
||||
"Welcome to the world of the future!\n" |
||||
"</body>\n"}; |
||||
|
||||
GPR_ASSERT(argc >= 1); |
||||
fake_argv[0] = argv[0]; |
||||
grpc_test_init(1, fake_argv); |
||||
|
||||
grpc_init(); |
||||
srand(clock()); |
||||
memset(arge, 0, sizeof(arge)); |
||||
args.args = arge; |
||||
|
||||
cl = gpr_cmdline_create("echo 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); |
||||
|
||||
e = &arge[args.num_args++]; |
||||
e->type = GRPC_ARG_POINTER; |
||||
e->key = GRPC_ARG_SERVE_OVER_HTTP; |
||||
e->value.pointer.p = &home_page; |
||||
|
||||
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(); |
||||
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); |
||||
server = grpc_server_create(cq, &args); |
||||
GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds)); |
||||
grpc_server_credentials_release(ssl_creds); |
||||
} else { |
||||
server = grpc_server_create(cq, &args); |
||||
GPR_ASSERT(grpc_server_add_http2_port(server, addr)); |
||||
} |
||||
grpc_server_start(server); |
||||
|
||||
gpr_free(addr_buf); |
||||
addr = addr_buf = NULL; |
||||
|
||||
request_call(); |
||||
|
||||
signal(SIGINT, sigint_handler); |
||||
while (!shutdown_finished) { |
||||
if (got_sigint && !shutdown_started) { |
||||
gpr_log(GPR_INFO, "Shutting down due to SIGINT"); |
||||
grpc_server_shutdown(server); |
||||
grpc_completion_queue_shutdown(cq); |
||||
shutdown_started = 1; |
||||
} |
||||
ev = grpc_completion_queue_next( |
||||
cq, gpr_time_add(gpr_now(), gpr_time_from_seconds(1))); |
||||
if (!ev) continue; |
||||
s = ev->tag; |
||||
switch (ev->type) { |
||||
case GRPC_SERVER_RPC_NEW: |
||||
if (ev->call != NULL) { |
||||
/* initial ops are already started in request_call */ |
||||
grpc_call_server_accept_old(ev->call, cq, s); |
||||
grpc_call_server_end_initial_metadata_old(ev->call, |
||||
GRPC_WRITE_BUFFER_HINT); |
||||
GPR_ASSERT(grpc_call_start_read_old(ev->call, s) == GRPC_CALL_OK); |
||||
request_call(); |
||||
} else { |
||||
GPR_ASSERT(shutdown_started); |
||||
gpr_free(s); |
||||
} |
||||
break; |
||||
case GRPC_WRITE_ACCEPTED: |
||||
GPR_ASSERT(ev->data.write_accepted == GRPC_OP_OK); |
||||
GPR_ASSERT(grpc_call_start_read_old(ev->call, s) == GRPC_CALL_OK); |
||||
break; |
||||
case GRPC_READ: |
||||
if (ev->data.read) { |
||||
assert_read_ok(ev->tag, ev->data.read); |
||||
GPR_ASSERT(grpc_call_start_write_old(ev->call, ev->data.read, s, |
||||
GRPC_WRITE_BUFFER_HINT) == |
||||
GRPC_CALL_OK); |
||||
} else { |
||||
GPR_ASSERT(grpc_call_start_write_status_old(ev->call, GRPC_STATUS_OK, |
||||
NULL, s) == GRPC_CALL_OK); |
||||
} |
||||
break; |
||||
case GRPC_FINISH_ACCEPTED: |
||||
case GRPC_FINISHED: |
||||
if (gpr_unref(&s->pending_ops)) { |
||||
grpc_call_destroy(ev->call); |
||||
gpr_free(s); |
||||
} |
||||
break; |
||||
case GRPC_QUEUE_SHUTDOWN: |
||||
GPR_ASSERT(shutdown_started); |
||||
shutdown_finished = 1; |
||||
break; |
||||
default: |
||||
GPR_ASSERT(0); |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
|
||||
grpc_server_destroy(server); |
||||
grpc_completion_queue_destroy(cq); |
||||
grpc_shutdown(); |
||||
|
||||
return 0; |
||||
} |
||||
@ -1,167 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
#include "test/core/end2end/tests/cancel_test_helpers.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Cancel after accept with a writes closed, no payload */ |
||||
static void test_cancel_after_accept_and_writes_closed( |
||||
grpc_end2end_test_config config, cancellation_mode mode) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.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, f.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_writes_done_old(c, tag(4))); |
||||
cq_expect_finish_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(s, tag(101))); |
||||
cq_expect_empty_read(v_server, tag(101)); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c)); |
||||
|
||||
cq_expect_finished_with_status(v_client, tag(3), mode.expect_status, |
||||
mode.expect_details, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_finished_with_status(v_server, tag(102), GRPC_STATUS_CANCELLED, |
||||
NULL, NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
unsigned i; |
||||
|
||||
for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) { |
||||
test_cancel_after_accept_and_writes_closed(config, cancellation_modes[i]); |
||||
} |
||||
} |
||||
@ -1,159 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
#include "test/core/end2end/tests/cancel_test_helpers.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Cancel after accept, no payload */ |
||||
static void test_cancel_after_accept(grpc_end2end_test_config config, |
||||
cancellation_mode mode) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.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, f.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 == mode.initiate_cancel(c)); |
||||
|
||||
cq_expect_finished_with_status(v_client, tag(3), mode.expect_status, |
||||
mode.expect_details, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_finished_with_status(v_server, tag(102), GRPC_STATUS_CANCELLED, |
||||
NULL, NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
unsigned i; |
||||
|
||||
for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) { |
||||
test_cancel_after_accept(config, cancellation_modes[i]); |
||||
} |
||||
} |
||||
@ -1,141 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
#include "test/core/end2end/tests/cancel_test_helpers.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Cancel after invoke, no payload */ |
||||
static void test_cancel_after_invoke(grpc_end2end_test_config config, |
||||
cancellation_mode mode) { |
||||
grpc_call *c; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c)); |
||||
|
||||
cq_expect_client_metadata_read(v_client, tag(2), NULL); |
||||
cq_expect_finished_with_status(v_client, tag(3), mode.expect_status, |
||||
mode.expect_details, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
grpc_call_destroy(c); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
unsigned i; |
||||
|
||||
for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) { |
||||
test_cancel_after_invoke(config, cancellation_modes[i]); |
||||
} |
||||
} |
||||
@ -1,134 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Cancel before invoke */ |
||||
static void test_cancel_before_invoke(grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
cq_expect_client_metadata_read(v_client, tag(2), NULL); |
||||
cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_CANCELLED, |
||||
"Cancelled", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
grpc_call_destroy(c); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_cancel_before_invoke(config); |
||||
} |
||||
@ -1,131 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
#include "test/core/end2end/tests/cancel_test_helpers.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Cancel and do nothing */ |
||||
static void test_cancel_in_a_vacuum(grpc_end2end_test_config config, |
||||
cancellation_mode mode) { |
||||
grpc_call *c; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c)); |
||||
|
||||
grpc_call_destroy(c); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
unsigned i; |
||||
|
||||
for (i = 0; i < GPR_ARRAY_SIZE(cancellation_modes); i++) { |
||||
test_cancel_in_a_vacuum(config, cancellation_modes[i]); |
||||
} |
||||
} |
||||
@ -1,178 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "src/core/support/string.h" |
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, n_seconds_time(5)); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static void test_body(grpc_end2end_test_fixture f) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = n_seconds_time(10); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
tag(1); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.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); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
static void test_invoke_request_with_census( |
||||
grpc_end2end_test_config config, const char *name, |
||||
void (*body)(grpc_end2end_test_fixture f)) { |
||||
char *fullname; |
||||
grpc_end2end_test_fixture f; |
||||
grpc_arg client_arg, server_arg; |
||||
grpc_channel_args client_args, server_args; |
||||
|
||||
client_arg.type = GRPC_ARG_INTEGER; |
||||
client_arg.key = GRPC_ARG_ENABLE_CENSUS; |
||||
client_arg.value.integer = 1; |
||||
|
||||
client_args.num_args = 1; |
||||
client_args.args = &client_arg; |
||||
|
||||
server_arg.type = GRPC_ARG_INTEGER; |
||||
server_arg.key = GRPC_ARG_ENABLE_CENSUS; |
||||
server_arg.value.integer = 1; |
||||
server_args.num_args = 1; |
||||
server_args.args = &server_arg; |
||||
|
||||
gpr_asprintf(&fullname, "%s/%s", __FUNCTION__, name); |
||||
f = begin_test(config, fullname, &client_args, &server_args); |
||||
body(f); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
gpr_free(fullname); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_invoke_request_with_census(config, "census_simple_request", test_body); |
||||
} |
||||
@ -1,168 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void do_request_and_shutdown_server(grpc_end2end_test_fixture *f, |
||||
cq_verifier *v_client, |
||||
cq_verifier *v_server) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
|
||||
c = grpc_channel_create_call_old(f->client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f->client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f->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, f->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); |
||||
|
||||
/* should be able to shut down the server early
|
||||
- and still complete the request */ |
||||
grpc_server_shutdown(f->server); |
||||
|
||||
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); |
||||
} |
||||
|
||||
static void disappearing_server_test(grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name); |
||||
|
||||
config.init_client(&f, NULL); |
||||
config.init_server(&f, NULL); |
||||
|
||||
do_request_and_shutdown_server(&f, v_client, v_server); |
||||
|
||||
/* now destroy and recreate the server */ |
||||
config.init_server(&f, NULL); |
||||
|
||||
do_request_and_shutdown_server(&f, v_client, v_server); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
if (config.feature_mask & FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION) { |
||||
disappearing_server_test(config); |
||||
} |
||||
} |
||||
@ -1,159 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void test_early_server_shutdown_finishes_inflight_calls( |
||||
grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.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); |
||||
|
||||
/* shutdown and destroy the server */ |
||||
shutdown_server(&f); |
||||
|
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(s); |
||||
|
||||
cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_UNAVAILABLE, |
||||
NULL, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
grpc_call_destroy(c); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_early_server_shutdown_finishes_inflight_calls(config); |
||||
} |
||||
@ -1,127 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void test_early_server_shutdown_finishes_tags( |
||||
grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
grpc_call *s = (void *)1; |
||||
|
||||
/* upon shutdown, the server should finish all requested calls indicating
|
||||
no new call */ |
||||
grpc_server_request_call_old(f.server, tag(1000)); |
||||
grpc_server_shutdown(f.server); |
||||
cq_expect_server_rpc_new(v_server, &s, tag(1000), NULL, NULL, gpr_inf_past, |
||||
NULL); |
||||
cq_verify(v_server); |
||||
GPR_ASSERT(s == NULL); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_early_server_shutdown_finishes_tags(config); |
||||
} |
||||
@ -1,160 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void test_early_server_shutdown_finishes_inflight_calls( |
||||
grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.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); |
||||
|
||||
/* shutdown the server */ |
||||
grpc_server_shutdown_and_notify(f.server, tag(0xdead)); |
||||
cq_verify_empty(v_server); |
||||
|
||||
grpc_call_start_write_status_old(s, GRPC_STATUS_OK, NULL, tag(103)); |
||||
grpc_call_destroy(s); |
||||
cq_expect_finish_accepted(v_server, tag(103), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_expect_server_shutdown(v_server, tag(0xdead)); |
||||
cq_verify(v_server); |
||||
|
||||
cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_OK, NULL, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
grpc_call_destroy(c); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_early_server_shutdown_finishes_inflight_calls(config); |
||||
} |
||||
@ -1,183 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, n_seconds_time(5)); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static gpr_slice large_slice(void) { |
||||
gpr_slice slice = gpr_slice_malloc(1000000); |
||||
memset(GPR_SLICE_START_PTR(slice), 0xab, GPR_SLICE_LENGTH(slice)); |
||||
return slice; |
||||
} |
||||
|
||||
static void test_invoke_large_request(grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = large_slice(); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
gpr_timespec deadline = n_seconds_time(30); |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
/* write should not be accepted until the server is willing to read the
|
||||
request (as this request is very large) */ |
||||
cq_verify_empty(v_client); |
||||
|
||||
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, f.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_read_old(s, tag(5))); |
||||
/* now the write can be accepted */ |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
cq_expect_read(v_server, tag(5), large_slice()); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
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(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_invoke_large_request(config); |
||||
} |
||||
@ -1,274 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void simple_request_body(grpc_end2end_test_fixture f) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.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); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
static void test_max_concurrent_streams(grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f; |
||||
grpc_arg server_arg; |
||||
grpc_channel_args server_args; |
||||
grpc_call *c1; |
||||
grpc_call *c2; |
||||
grpc_call *s1; |
||||
grpc_call *s2; |
||||
int live_call; |
||||
gpr_timespec deadline; |
||||
cq_verifier *v_client; |
||||
cq_verifier *v_server; |
||||
grpc_event *ev; |
||||
|
||||
server_arg.key = GRPC_ARG_MAX_CONCURRENT_STREAMS; |
||||
server_arg.type = GRPC_ARG_INTEGER; |
||||
server_arg.value.integer = 1; |
||||
|
||||
server_args.num_args = 1; |
||||
server_args.args = &server_arg; |
||||
|
||||
f = begin_test(config, __FUNCTION__, NULL, &server_args); |
||||
v_client = cq_verifier_create(f.client_cq); |
||||
v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* perform a ping-pong to ensure that settings have had a chance to round
|
||||
trip */ |
||||
simple_request_body(f); |
||||
/* perform another one to make sure that the one stream case still works */ |
||||
simple_request_body(f); |
||||
|
||||
/* start two requests - ensuring that the second is not accepted until
|
||||
the first completes */ |
||||
deadline = five_seconds_time(); |
||||
c1 = grpc_channel_create_call_old(f.client, "/alpha", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c1); |
||||
c2 = grpc_channel_create_call_old(f.client, "/beta", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c1); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c1, f.client_cq, tag(301), tag(302), 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c2, f.client_cq, tag(401), tag(402), 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c1, tag(303))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c2, tag(403))); |
||||
|
||||
ev = grpc_completion_queue_next( |
||||
f.client_cq, gpr_time_add(gpr_now(), gpr_time_from_seconds(10))); |
||||
GPR_ASSERT(ev); |
||||
GPR_ASSERT(ev->type == GRPC_FINISH_ACCEPTED); |
||||
GPR_ASSERT(ev->data.invoke_accepted == GRPC_OP_OK); |
||||
/* The /alpha or /beta calls started above could be invoked (but NOT both);
|
||||
* check this here */ |
||||
/* We'll get tag 303 or 403, we want 300, 400 */ |
||||
live_call = ((int)(gpr_intptr) ev->tag) - 3; |
||||
grpc_event_finish(ev); |
||||
|
||||
cq_expect_server_rpc_new(v_server, &s1, tag(100), |
||||
live_call == 300 ? "/alpha" : "/beta", |
||||
"foo.test.google.fr", deadline, NULL); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_accept_old(s1, f.server_cq, tag(102))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_end_initial_metadata_old(s1, 0)); |
||||
cq_expect_client_metadata_read(v_client, tag(live_call + 1), NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_status_old(s1, GRPC_STATUS_UNIMPLEMENTED, |
||||
"xyz", tag(103))); |
||||
cq_expect_finish_accepted(v_server, tag(103), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
/* first request is finished, we should be able to start the second */ |
||||
cq_expect_finished_with_status(v_client, tag(live_call + 2), |
||||
GRPC_STATUS_UNIMPLEMENTED, "xyz", NULL); |
||||
live_call = (live_call == 300) ? 400 : 300; |
||||
cq_expect_finish_accepted(v_client, tag(live_call + 3), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(200))); |
||||
cq_expect_server_rpc_new(v_server, &s2, tag(200), |
||||
live_call == 300 ? "/alpha" : "/beta", |
||||
"foo.test.google.fr", deadline, NULL); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_accept_old(s2, f.server_cq, tag(202))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_end_initial_metadata_old(s2, 0)); |
||||
cq_expect_client_metadata_read(v_client, tag(live_call + 1), NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_status_old(s2, GRPC_STATUS_UNIMPLEMENTED, |
||||
"xyz", tag(203))); |
||||
cq_expect_finish_accepted(v_server, tag(203), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(202), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
cq_expect_finished_with_status(v_client, tag(live_call + 2), |
||||
GRPC_STATUS_UNIMPLEMENTED, "xyz", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
grpc_call_destroy(c1); |
||||
grpc_call_destroy(s1); |
||||
grpc_call_destroy(c2); |
||||
grpc_call_destroy(s2); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_max_concurrent_streams(config); |
||||
} |
||||
@ -1,109 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void test_no_op(grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { test_no_op(config); } |
||||
@ -1,203 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Client pings and server pongs. Repeat messages rounds before finishing. */ |
||||
static void test_pingpong_streaming(grpc_end2end_test_config config, |
||||
int messages) { |
||||
int i; |
||||
grpc_call *c; |
||||
grpc_call *s = NULL; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = NULL; |
||||
grpc_byte_buffer *response_payload = NULL; |
||||
gpr_timespec deadline = n_seconds_time(messages * 5); |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
gpr_log(GPR_INFO, "testing with %d message pairs.", messages); |
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.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, f.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); |
||||
|
||||
for (i = 0; i < messages; i++) { |
||||
request_payload = grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(2), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its
|
||||
contents |
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(2), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(s, tag(3))); |
||||
cq_expect_read(v_server, tag(3), |
||||
gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
response_payload = grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its
|
||||
contents |
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(5))); |
||||
cq_expect_read(v_client, tag(5), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
} |
||||
|
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(6))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(7))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK); |
||||
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(7), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
int i; |
||||
|
||||
for (i = 1; i < 10; i++) { |
||||
test_pingpong_streaming(config, i); |
||||
} |
||||
} |
||||
@ -1,231 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Request/response with metadata and payload.*/ |
||||
static void test_request_response_with_metadata_and_payload( |
||||
grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
/* staggered lengths to ensure we hit various branches in base64 encode/decode
|
||||
*/ |
||||
grpc_metadata meta1 = {"key1-bin", |
||||
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc", |
||||
13, |
||||
{{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta2 = { |
||||
"key2-bin", |
||||
"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d", |
||||
14, |
||||
{{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta3 = { |
||||
"key3-bin", |
||||
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee", |
||||
15, |
||||
{{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta4 = { |
||||
"key4-bin", |
||||
"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", |
||||
16, |
||||
{{NULL, NULL, NULL}}}; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta1, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta2, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_server_rpc_new( |
||||
v_server, &s, tag(100), "/foo", "foo.test.google.fr", deadline, |
||||
"key1-bin", "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc", |
||||
"key2-bin", "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d", |
||||
NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_server_accept_old(s, f.server_cq, tag(102)); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta3, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta4, 0)); |
||||
|
||||
grpc_call_server_end_initial_metadata_old(s, 0); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
/* fetch metadata.. */ |
||||
cq_expect_client_metadata_read( |
||||
v_client, tag(2), "key3-bin", |
||||
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee", |
||||
"key4-bin", |
||||
"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(7))); |
||||
cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
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(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_request_response_with_metadata_and_payload(config); |
||||
} |
||||
@ -1,208 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Request/response with metadata and payload.*/ |
||||
static void test_request_response_with_metadata_and_payload( |
||||
grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_metadata meta1 = {"key1", "val1", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta2 = {"key2", "val2", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta3 = {"key3", "val3", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta4 = {"key4", "val4", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta1, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta2, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "foo.test.google.fr", |
||||
deadline, "key1", "val1", "key2", "val2", NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_server_accept_old(s, f.server_cq, tag(102)); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta3, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta4, 0)); |
||||
|
||||
grpc_call_server_end_initial_metadata_old(s, 0); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
/* fetch metadata.. */ |
||||
cq_expect_client_metadata_read(v_client, tag(2), "key3", "val3", "key4", |
||||
"val4", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(7))); |
||||
cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
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(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_request_response_with_metadata_and_payload(config); |
||||
} |
||||
@ -1,208 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void request_response_with_payload(grpc_end2end_test_fixture f) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
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, f.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_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(7))); |
||||
cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you")); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
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(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
/* Client sends a request with payload, server reads then returns a response
|
||||
payload and status. */ |
||||
static void test_invoke_request_response_with_payload( |
||||
grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
request_response_with_payload(f); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
static void test_invoke_10_request_response_with_payload( |
||||
grpc_end2end_test_config config) { |
||||
int i; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
for (i = 0; i < 10; i++) { |
||||
request_response_with_payload(f); |
||||
} |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_invoke_request_response_with_payload(config); |
||||
test_invoke_10_request_response_with_payload(config); |
||||
} |
||||
@ -1,213 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Request/response with metadata and payload.*/ |
||||
static void test_request_response_with_metadata_and_payload( |
||||
grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_metadata meta1 = {"key1", "val1", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta2 = {"key2", "val2", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta3 = {"key3", "val3", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta4 = {"key4", "val4", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta5 = {"key5", "val5", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_metadata meta6 = {"key6", "val6", 4, {{NULL, NULL, NULL}}}; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta1, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta2, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "foo.test.google.fr", |
||||
deadline, "key1", "val1", "key2", "val2", NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_server_accept_old(s, f.server_cq, tag(102)); |
||||
|
||||
/* add multiple metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta3, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta4, 0)); |
||||
|
||||
grpc_call_server_end_initial_metadata_old(s, 0); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta5, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(s, &meta6, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
/* fetch metadata.. */ |
||||
cq_expect_client_metadata_read(v_client, tag(2), "key3", "val3", "key4", |
||||
"val4", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(7))); |
||||
cq_expect_read(v_client, tag(7), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_UNIMPLEMENTED, |
||||
"xyz", "key5", "val5", "key6", "val6", NULL); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_request_response_with_metadata_and_payload(config); |
||||
} |
||||
@ -1,172 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Request with a large amount of metadata.*/ |
||||
static void test_request_with_large_metadata(grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_metadata meta; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
const int large_size = 64 * 1024; |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
meta.key = "key"; |
||||
meta.value = gpr_malloc(large_size + 1); |
||||
memset((char *)meta.value, 'a', large_size); |
||||
((char *)meta.value)[large_size] = 0; |
||||
meta.value_length = large_size; |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
/* add the metadata */ |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_add_metadata_old(c, &meta, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
cq_expect_server_rpc_new(v_server, &s, tag(100), "/foo", "foo.test.google.fr", |
||||
deadline, "key", meta.value, NULL); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_accept_old(s, f.server_cq, tag(102))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_end_initial_metadata_old(s, 0)); |
||||
|
||||
/* fetch metadata.. */ |
||||
cq_expect_client_metadata_read(v_client, tag(2), NULL); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(8))); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_status_old(s, GRPC_STATUS_OK, NULL, tag(9))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(8), GRPC_OP_OK); |
||||
cq_expect_finished_with_status(v_client, tag(3), GRPC_STATUS_OK, NULL, NULL); |
||||
cq_verify(v_client); |
||||
|
||||
cq_expect_finish_accepted(v_server, tag(9), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
|
||||
gpr_free((char *)meta.value); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_request_with_large_metadata(config); |
||||
} |
||||
@ -1,172 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* Client sends a request with payload, server reads then returns status. */ |
||||
static void test_invoke_request_with_payload(grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
grpc_byte_buffer *payload = grpc_byte_buffer_create(&payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.server, tag(100))); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_old(c, payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
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, f.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_read_old(s, tag(4))); |
||||
cq_expect_read(v_server, tag(4), gpr_slice_from_copied_string("hello world")); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(5))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(6))); |
||||
cq_expect_finish_accepted(v_client, tag(5), GRPC_OP_OK); |
||||
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(6), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_invoke_request_with_payload(config); |
||||
} |
||||
@ -1,175 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void simple_delayed_request_body(grpc_end2end_test_config config, |
||||
grpc_end2end_test_fixture *f, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args, |
||||
long delay_us) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f->client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f->server_cq); |
||||
|
||||
config.init_client(f, client_args); |
||||
|
||||
c = grpc_channel_create_call_old(f->client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f->client_cq, tag(2), tag(3), 0)); |
||||
|
||||
config.init_server(f, server_args); |
||||
|
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f->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, f->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); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
static void test_simple_delayed_request_short(grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f; |
||||
|
||||
gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name); |
||||
f = config.create_fixture(NULL, NULL); |
||||
simple_delayed_request_body(config, &f, NULL, NULL, 100000); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
static void test_simple_delayed_request_long(grpc_end2end_test_config config) { |
||||
grpc_end2end_test_fixture f; |
||||
|
||||
gpr_log(GPR_INFO, "%s/%s", __FUNCTION__, config.name); |
||||
f = config.create_fixture(NULL, NULL); |
||||
/* This timeout should be longer than a single retry */ |
||||
simple_delayed_request_body(config, &f, NULL, NULL, 1500000); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
if (config.feature_mask & FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION) { |
||||
test_simple_delayed_request_short(config); |
||||
test_simple_delayed_request_long(config); |
||||
} |
||||
} |
||||
@ -1,232 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "src/core/support/string.h" |
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
static void simple_request_body(grpc_end2end_test_fixture f) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.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); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
/* an alternative ordering of the simple request body */ |
||||
static void simple_request_body2(grpc_end2end_test_fixture f) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(4))); |
||||
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(f.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, f.server_cq, tag(102))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_server_end_initial_metadata_old(s, 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(5))); |
||||
cq_verify(v_server); |
||||
|
||||
cq_expect_client_metadata_read(v_client, tag(2), NULL); |
||||
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); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
static void test_invoke_simple_request( |
||||
grpc_end2end_test_config config, const char *name, |
||||
void (*body)(grpc_end2end_test_fixture f)) { |
||||
char *fullname; |
||||
grpc_end2end_test_fixture f; |
||||
|
||||
gpr_asprintf(&fullname, "%s/%s", __FUNCTION__, name); |
||||
|
||||
f = begin_test(config, fullname, NULL, NULL); |
||||
body(f); |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
gpr_free(fullname); |
||||
} |
||||
|
||||
static void test_invoke_10_simple_requests(grpc_end2end_test_config config) { |
||||
int i; |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
for (i = 0; i < 10; i++) { |
||||
simple_request_body(f); |
||||
gpr_log(GPR_INFO, "Passed simple request %d", i); |
||||
} |
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_invoke_simple_request(config, "simple_request_body", |
||||
simple_request_body); |
||||
test_invoke_simple_request(config, "simple_request_body2", |
||||
simple_request_body2); |
||||
test_invoke_10_simple_requests(config); |
||||
} |
||||
@ -1,325 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "src/core/surface/event_string.h" |
||||
#include "src/core/surface/completion_queue.h" |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/thd.h> |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
#define SERVER_THREADS 16 |
||||
#define CLIENT_THREADS 16 |
||||
|
||||
static grpc_end2end_test_fixture g_fixture; |
||||
static gpr_timespec g_test_end_time; |
||||
static gpr_event g_client_done[CLIENT_THREADS]; |
||||
static gpr_event g_server_done[SERVER_THREADS]; |
||||
static gpr_mu g_mu; |
||||
static int g_active_requests; |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
/* Drain pending events on a completion queue until it's ready to destroy.
|
||||
Does some post-processing to safely release memory on some of the events. */ |
||||
static void drain_cq(int client, grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
char *evstr; |
||||
int done = 0; |
||||
char *name = client ? "client" : "server"; |
||||
while (!done) { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
if (!ev) { |
||||
gpr_log(GPR_ERROR, "waiting for %s cq to drain", name); |
||||
grpc_cq_dump_pending_ops(cq); |
||||
continue; |
||||
} |
||||
|
||||
evstr = grpc_event_string(ev); |
||||
gpr_log(GPR_INFO, "got late %s event: %s", name, evstr); |
||||
gpr_free(evstr); |
||||
|
||||
type = ev->type; |
||||
switch (type) { |
||||
case GRPC_SERVER_RPC_NEW: |
||||
gpr_free(ev->tag); |
||||
if (ev->call) { |
||||
grpc_call_destroy(ev->call); |
||||
} |
||||
break; |
||||
case GRPC_FINISHED: |
||||
grpc_call_destroy(ev->call); |
||||
break; |
||||
case GRPC_QUEUE_SHUTDOWN: |
||||
done = 1; |
||||
break; |
||||
case GRPC_READ: |
||||
case GRPC_WRITE_ACCEPTED: |
||||
if (!client && gpr_unref(ev->tag)) { |
||||
gpr_free(ev->tag); |
||||
} |
||||
default: |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
} |
||||
|
||||
/* Kick off a new request - assumes g_mu taken */ |
||||
static void start_request(void) { |
||||
gpr_slice slice = gpr_slice_malloc(100); |
||||
grpc_byte_buffer *buf; |
||||
grpc_call *call = grpc_channel_create_call_old( |
||||
g_fixture.client, "/Foo", "foo.test.google.fr", g_test_end_time); |
||||
|
||||
memset(GPR_SLICE_START_PTR(slice), 1, GPR_SLICE_LENGTH(slice)); |
||||
buf = grpc_byte_buffer_create(&slice, 1); |
||||
gpr_slice_unref(slice); |
||||
|
||||
g_active_requests++; |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(call, g_fixture.client_cq, NULL, NULL, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(call, NULL)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_old(call, buf, NULL, 0)); |
||||
|
||||
grpc_byte_buffer_destroy(buf); |
||||
} |
||||
|
||||
/* Async client: handle sending requests, reading responses, and starting
|
||||
new requests when old ones finish */ |
||||
static void client_thread(void *p) { |
||||
gpr_intptr id = (gpr_intptr)p; |
||||
grpc_event *ev; |
||||
char *estr; |
||||
|
||||
for (;;) { |
||||
ev = grpc_completion_queue_next(g_fixture.client_cq, n_seconds_time(1)); |
||||
if (ev) { |
||||
switch (ev->type) { |
||||
default: |
||||
estr = grpc_event_string(ev); |
||||
gpr_log(GPR_ERROR, "unexpected event: %s", estr); |
||||
gpr_free(estr); |
||||
break; |
||||
case GRPC_READ: |
||||
break; |
||||
case GRPC_WRITE_ACCEPTED: |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(ev->call, NULL)); |
||||
break; |
||||
case GRPC_FINISH_ACCEPTED: |
||||
break; |
||||
case GRPC_CLIENT_METADATA_READ: |
||||
break; |
||||
case GRPC_FINISHED: |
||||
/* kick off a new request if the test should still be running */ |
||||
gpr_mu_lock(&g_mu); |
||||
g_active_requests--; |
||||
if (gpr_time_cmp(gpr_now(), g_test_end_time) < 0) { |
||||
start_request(); |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
grpc_call_destroy(ev->call); |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
gpr_mu_lock(&g_mu); |
||||
if (g_active_requests == 0) { |
||||
gpr_mu_unlock(&g_mu); |
||||
break; |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
} |
||||
|
||||
gpr_event_set(&g_client_done[id], (void *)1); |
||||
} |
||||
|
||||
/* Request a new server call. We tag them with a ref-count that starts at two,
|
||||
and decrements after each of: a read completes and a write completes. |
||||
When it drops to zero, we write status */ |
||||
static void request_server_call(void) { |
||||
gpr_refcount *rc = gpr_malloc(sizeof(gpr_refcount)); |
||||
gpr_ref_init(rc, 2); |
||||
grpc_server_request_call_old(g_fixture.server, rc); |
||||
} |
||||
|
||||
static void maybe_end_server_call(grpc_call *call, gpr_refcount *rc) { |
||||
if (gpr_unref(rc)) { |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
call, GRPC_STATUS_OK, NULL, NULL)); |
||||
gpr_free(rc); |
||||
} |
||||
} |
||||
|
||||
static void server_thread(void *p) { |
||||
int id = (gpr_intptr)p; |
||||
gpr_slice slice = gpr_slice_malloc(100); |
||||
grpc_byte_buffer *buf; |
||||
grpc_event *ev; |
||||
char *estr; |
||||
|
||||
memset(GPR_SLICE_START_PTR(slice), 1, GPR_SLICE_LENGTH(slice)); |
||||
buf = grpc_byte_buffer_create(&slice, 1); |
||||
gpr_slice_unref(slice); |
||||
|
||||
request_server_call(); |
||||
|
||||
for (;;) { |
||||
ev = grpc_completion_queue_next(g_fixture.server_cq, n_seconds_time(1)); |
||||
if (ev) { |
||||
switch (ev->type) { |
||||
default: |
||||
estr = grpc_event_string(ev); |
||||
gpr_log(GPR_ERROR, "unexpected event: %s", estr); |
||||
gpr_free(estr); |
||||
break; |
||||
case GRPC_SERVER_RPC_NEW: |
||||
if (ev->call) { |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_accept_old( |
||||
ev->call, g_fixture.server_cq, ev->tag)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_end_initial_metadata_old(ev->call, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_read_old(ev->call, ev->tag)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(ev->call, buf, ev->tag, 0)); |
||||
} else { |
||||
gpr_free(ev->tag); |
||||
} |
||||
break; |
||||
case GRPC_READ: |
||||
if (ev->data.read) { |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_read_old(ev->call, ev->tag)); |
||||
} else { |
||||
maybe_end_server_call(ev->call, ev->tag); |
||||
} |
||||
break; |
||||
case GRPC_WRITE_ACCEPTED: |
||||
maybe_end_server_call(ev->call, ev->tag); |
||||
break; |
||||
case GRPC_FINISH_ACCEPTED: |
||||
break; |
||||
case GRPC_FINISHED: |
||||
grpc_call_destroy(ev->call); |
||||
request_server_call(); |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
gpr_mu_lock(&g_mu); |
||||
if (g_active_requests == 0) { |
||||
gpr_mu_unlock(&g_mu); |
||||
break; |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
} |
||||
|
||||
grpc_byte_buffer_destroy(buf); |
||||
gpr_event_set(&g_server_done[id], (void *)1); |
||||
} |
||||
|
||||
static void run_test(grpc_end2end_test_config config, int requests_in_flight) { |
||||
int i; |
||||
gpr_thd_id thd_id; |
||||
|
||||
gpr_log(GPR_INFO, "thread_stress_test/%s @ %d requests", config.name, |
||||
requests_in_flight); |
||||
|
||||
/* setup client, server */ |
||||
g_fixture = config.create_fixture(NULL, NULL); |
||||
config.init_client(&g_fixture, NULL); |
||||
config.init_server(&g_fixture, NULL); |
||||
|
||||
/* schedule end time */ |
||||
g_test_end_time = n_seconds_time(5); |
||||
|
||||
g_active_requests = 0; |
||||
gpr_mu_init(&g_mu); |
||||
|
||||
/* kick off threads */ |
||||
for (i = 0; i < CLIENT_THREADS; i++) { |
||||
gpr_event_init(&g_client_done[i]); |
||||
gpr_thd_new(&thd_id, client_thread, (void *)(gpr_intptr) i, NULL); |
||||
} |
||||
for (i = 0; i < SERVER_THREADS; i++) { |
||||
gpr_event_init(&g_server_done[i]); |
||||
gpr_thd_new(&thd_id, server_thread, (void *)(gpr_intptr) i, NULL); |
||||
} |
||||
|
||||
/* start requests */ |
||||
gpr_mu_lock(&g_mu); |
||||
for (i = 0; i < requests_in_flight; i++) { |
||||
start_request(); |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
|
||||
/* await completion */ |
||||
for (i = 0; i < CLIENT_THREADS; i++) { |
||||
gpr_event_wait(&g_client_done[i], gpr_inf_future); |
||||
} |
||||
for (i = 0; i < SERVER_THREADS; i++) { |
||||
gpr_event_wait(&g_server_done[i], gpr_inf_future); |
||||
} |
||||
|
||||
/* shutdown the things */ |
||||
grpc_server_shutdown(g_fixture.server); |
||||
grpc_server_destroy(g_fixture.server); |
||||
grpc_channel_destroy(g_fixture.client); |
||||
|
||||
grpc_completion_queue_shutdown(g_fixture.server_cq); |
||||
drain_cq(0, g_fixture.server_cq); |
||||
grpc_completion_queue_destroy(g_fixture.server_cq); |
||||
grpc_completion_queue_shutdown(g_fixture.client_cq); |
||||
drain_cq(1, g_fixture.client_cq); |
||||
grpc_completion_queue_destroy(g_fixture.client_cq); |
||||
|
||||
config.tear_down_data(&g_fixture); |
||||
|
||||
gpr_mu_destroy(&g_mu); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
run_test(config, 1000); |
||||
} |
||||
@ -1,325 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "src/core/surface/event_string.h" |
||||
#include "src/core/surface/completion_queue.h" |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/thd.h> |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
#define SERVER_THREADS 16 |
||||
#define CLIENT_THREADS 16 |
||||
|
||||
static grpc_end2end_test_fixture g_fixture; |
||||
static gpr_timespec g_test_end_time; |
||||
static gpr_event g_client_done[CLIENT_THREADS]; |
||||
static gpr_event g_server_done[SERVER_THREADS]; |
||||
static gpr_mu g_mu; |
||||
static int g_active_requests; |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
/* Drain pending events on a completion queue until it's ready to destroy.
|
||||
Does some post-processing to safely release memory on some of the events. */ |
||||
static void drain_cq(int client, grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
char *evstr; |
||||
int done = 0; |
||||
char *name = client ? "client" : "server"; |
||||
while (!done) { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
if (!ev) { |
||||
gpr_log(GPR_ERROR, "waiting for %s cq to drain", name); |
||||
grpc_cq_dump_pending_ops(cq); |
||||
continue; |
||||
} |
||||
|
||||
evstr = grpc_event_string(ev); |
||||
gpr_log(GPR_INFO, "got late %s event: %s", name, evstr); |
||||
gpr_free(evstr); |
||||
|
||||
type = ev->type; |
||||
switch (type) { |
||||
case GRPC_SERVER_RPC_NEW: |
||||
gpr_free(ev->tag); |
||||
if (ev->call) { |
||||
grpc_call_destroy(ev->call); |
||||
} |
||||
break; |
||||
case GRPC_FINISHED: |
||||
grpc_call_destroy(ev->call); |
||||
break; |
||||
case GRPC_QUEUE_SHUTDOWN: |
||||
done = 1; |
||||
break; |
||||
case GRPC_READ: |
||||
case GRPC_WRITE_ACCEPTED: |
||||
if (!client && gpr_unref(ev->tag)) { |
||||
gpr_free(ev->tag); |
||||
} |
||||
default: |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
} |
||||
|
||||
/* Kick off a new request - assumes g_mu taken */ |
||||
static void start_request(void) { |
||||
gpr_slice slice = gpr_slice_malloc(100); |
||||
grpc_byte_buffer *buf; |
||||
grpc_call *call = grpc_channel_create_call_old( |
||||
g_fixture.client, "/Foo", "foo.test.google.fr", g_test_end_time); |
||||
|
||||
memset(GPR_SLICE_START_PTR(slice), 1, GPR_SLICE_LENGTH(slice)); |
||||
buf = grpc_byte_buffer_create(&slice, 1); |
||||
gpr_slice_unref(slice); |
||||
|
||||
g_active_requests++; |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(call, g_fixture.client_cq, NULL, NULL, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(call, NULL)); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_old(call, buf, NULL, 0)); |
||||
|
||||
grpc_byte_buffer_destroy(buf); |
||||
} |
||||
|
||||
/* Async client: handle sending requests, reading responses, and starting
|
||||
new requests when old ones finish */ |
||||
static void client_thread(void *p) { |
||||
gpr_intptr id = (gpr_intptr)p; |
||||
grpc_event *ev; |
||||
char *estr; |
||||
|
||||
for (;;) { |
||||
ev = grpc_completion_queue_next(g_fixture.client_cq, n_seconds_time(1)); |
||||
if (ev) { |
||||
switch (ev->type) { |
||||
default: |
||||
estr = grpc_event_string(ev); |
||||
gpr_log(GPR_ERROR, "unexpected event: %s", estr); |
||||
gpr_free(estr); |
||||
break; |
||||
case GRPC_READ: |
||||
break; |
||||
case GRPC_WRITE_ACCEPTED: |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(ev->call, NULL)); |
||||
break; |
||||
case GRPC_FINISH_ACCEPTED: |
||||
break; |
||||
case GRPC_CLIENT_METADATA_READ: |
||||
break; |
||||
case GRPC_FINISHED: |
||||
/* kick off a new request if the test should still be running */ |
||||
gpr_mu_lock(&g_mu); |
||||
g_active_requests--; |
||||
if (gpr_time_cmp(gpr_now(), g_test_end_time) < 0) { |
||||
start_request(); |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
grpc_call_destroy(ev->call); |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
gpr_mu_lock(&g_mu); |
||||
if (g_active_requests == 0) { |
||||
gpr_mu_unlock(&g_mu); |
||||
break; |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
} |
||||
|
||||
gpr_event_set(&g_client_done[id], (void *)1); |
||||
} |
||||
|
||||
/* Request a new server call. We tag them with a ref-count that starts at two,
|
||||
and decrements after each of: a read completes and a write completes. |
||||
When it drops to zero, we write status */ |
||||
static void request_server_call(void) { |
||||
gpr_refcount *rc = gpr_malloc(sizeof(gpr_refcount)); |
||||
gpr_ref_init(rc, 2); |
||||
grpc_server_request_call_old(g_fixture.server, rc); |
||||
} |
||||
|
||||
static void maybe_end_server_call(grpc_call *call, gpr_refcount *rc) { |
||||
if (gpr_unref(rc)) { |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
call, GRPC_STATUS_OK, NULL, NULL)); |
||||
gpr_free(rc); |
||||
} |
||||
} |
||||
|
||||
static void server_thread(void *p) { |
||||
int id = (gpr_intptr)p; |
||||
gpr_slice slice = gpr_slice_malloc(100); |
||||
grpc_byte_buffer *buf; |
||||
grpc_event *ev; |
||||
char *estr; |
||||
|
||||
memset(GPR_SLICE_START_PTR(slice), 1, GPR_SLICE_LENGTH(slice)); |
||||
buf = grpc_byte_buffer_create(&slice, 1); |
||||
gpr_slice_unref(slice); |
||||
|
||||
request_server_call(); |
||||
|
||||
for (;;) { |
||||
ev = grpc_completion_queue_next(g_fixture.server_cq, n_seconds_time(1)); |
||||
if (ev) { |
||||
switch (ev->type) { |
||||
default: |
||||
estr = grpc_event_string(ev); |
||||
gpr_log(GPR_ERROR, "unexpected event: %s", estr); |
||||
gpr_free(estr); |
||||
break; |
||||
case GRPC_SERVER_RPC_NEW: |
||||
if (ev->call) { |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_accept_old( |
||||
ev->call, g_fixture.server_cq, ev->tag)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_server_end_initial_metadata_old(ev->call, 0)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_read_old(ev->call, ev->tag)); |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(ev->call, buf, ev->tag, 0)); |
||||
} else { |
||||
gpr_free(ev->tag); |
||||
} |
||||
break; |
||||
case GRPC_READ: |
||||
if (ev->data.read) { |
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_read_old(ev->call, ev->tag)); |
||||
} else { |
||||
maybe_end_server_call(ev->call, ev->tag); |
||||
} |
||||
break; |
||||
case GRPC_WRITE_ACCEPTED: |
||||
maybe_end_server_call(ev->call, ev->tag); |
||||
break; |
||||
case GRPC_FINISH_ACCEPTED: |
||||
break; |
||||
case GRPC_FINISHED: |
||||
grpc_call_destroy(ev->call); |
||||
request_server_call(); |
||||
break; |
||||
} |
||||
grpc_event_finish(ev); |
||||
} |
||||
gpr_mu_lock(&g_mu); |
||||
if (g_active_requests == 0) { |
||||
gpr_mu_unlock(&g_mu); |
||||
break; |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
} |
||||
|
||||
grpc_byte_buffer_destroy(buf); |
||||
gpr_event_set(&g_server_done[id], (void *)1); |
||||
} |
||||
|
||||
static void run_test(grpc_end2end_test_config config, int requests_in_flight) { |
||||
int i; |
||||
gpr_thd_id thd_id; |
||||
|
||||
gpr_log(GPR_INFO, "thread_stress_test/%s @ %d requests", config.name, |
||||
requests_in_flight); |
||||
|
||||
/* setup client, server */ |
||||
g_fixture = config.create_fixture(NULL, NULL); |
||||
config.init_client(&g_fixture, NULL); |
||||
config.init_server(&g_fixture, NULL); |
||||
|
||||
/* schedule end time */ |
||||
g_test_end_time = n_seconds_time(5); |
||||
|
||||
g_active_requests = 0; |
||||
gpr_mu_init(&g_mu); |
||||
|
||||
/* kick off threads */ |
||||
for (i = 0; i < CLIENT_THREADS; i++) { |
||||
gpr_event_init(&g_client_done[i]); |
||||
gpr_thd_new(&thd_id, client_thread, (void *)(gpr_intptr) i, NULL); |
||||
} |
||||
for (i = 0; i < SERVER_THREADS; i++) { |
||||
gpr_event_init(&g_server_done[i]); |
||||
gpr_thd_new(&thd_id, server_thread, (void *)(gpr_intptr) i, NULL); |
||||
} |
||||
|
||||
/* start requests */ |
||||
gpr_mu_lock(&g_mu); |
||||
for (i = 0; i < requests_in_flight; i++) { |
||||
start_request(); |
||||
} |
||||
gpr_mu_unlock(&g_mu); |
||||
|
||||
/* await completion */ |
||||
for (i = 0; i < CLIENT_THREADS; i++) { |
||||
gpr_event_wait(&g_client_done[i], gpr_inf_future); |
||||
} |
||||
for (i = 0; i < SERVER_THREADS; i++) { |
||||
gpr_event_wait(&g_server_done[i], gpr_inf_future); |
||||
} |
||||
|
||||
/* shutdown the things */ |
||||
grpc_server_shutdown(g_fixture.server); |
||||
grpc_server_destroy(g_fixture.server); |
||||
grpc_channel_destroy(g_fixture.client); |
||||
|
||||
grpc_completion_queue_shutdown(g_fixture.server_cq); |
||||
drain_cq(0, g_fixture.server_cq); |
||||
grpc_completion_queue_destroy(g_fixture.server_cq); |
||||
grpc_completion_queue_shutdown(g_fixture.client_cq); |
||||
drain_cq(1, g_fixture.client_cq); |
||||
grpc_completion_queue_destroy(g_fixture.client_cq); |
||||
|
||||
config.tear_down_data(&g_fixture); |
||||
|
||||
gpr_mu_destroy(&g_mu); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
run_test(config, 1000); |
||||
} |
||||
@ -1,199 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* test the case when there is a pending message at the client side,
|
||||
writes_done should not return a status without a start_read. |
||||
Note: this test will last for 3s. Do not run in a loop. */ |
||||
static void test_writes_done_hangs_with_pending_read( |
||||
grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.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, f.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_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(6))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(7))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
/* does not return status because there is a pending message to be read */ |
||||
cq_verify_empty(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(8))); |
||||
cq_expect_read(v_client, tag(8), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
|
||||
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(7), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_writes_done_hangs_with_pending_read(config); |
||||
} |
||||
@ -1,199 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "test/core/end2end/end2end_tests.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <unistd.h> |
||||
|
||||
#include <grpc/byte_buffer.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/time.h> |
||||
#include <grpc/support/useful.h> |
||||
#include "test/core/end2end/cq_verifier.h" |
||||
|
||||
enum { TIMEOUT = 200000 }; |
||||
|
||||
static void *tag(gpr_intptr t) { return (void *)t; } |
||||
|
||||
static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
||||
const char *test_name, |
||||
grpc_channel_args *client_args, |
||||
grpc_channel_args *server_args) { |
||||
grpc_end2end_test_fixture f; |
||||
gpr_log(GPR_INFO, "%s/%s", test_name, config.name); |
||||
f = config.create_fixture(client_args, server_args); |
||||
config.init_client(&f, client_args); |
||||
config.init_server(&f, server_args); |
||||
return f; |
||||
} |
||||
|
||||
static gpr_timespec n_seconds_time(int n) { |
||||
return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); |
||||
} |
||||
|
||||
static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } |
||||
|
||||
static void drain_cq(grpc_completion_queue *cq) { |
||||
grpc_event *ev; |
||||
grpc_completion_type type; |
||||
do { |
||||
ev = grpc_completion_queue_next(cq, five_seconds_time()); |
||||
GPR_ASSERT(ev); |
||||
type = ev->type; |
||||
grpc_event_finish(ev); |
||||
} while (type != GRPC_QUEUE_SHUTDOWN); |
||||
} |
||||
|
||||
static void shutdown_server(grpc_end2end_test_fixture *f) { |
||||
if (!f->server) return; |
||||
grpc_server_shutdown(f->server); |
||||
grpc_server_destroy(f->server); |
||||
f->server = NULL; |
||||
} |
||||
|
||||
static void shutdown_client(grpc_end2end_test_fixture *f) { |
||||
if (!f->client) return; |
||||
grpc_channel_destroy(f->client); |
||||
f->client = NULL; |
||||
} |
||||
|
||||
static void end_test(grpc_end2end_test_fixture *f) { |
||||
shutdown_server(f); |
||||
shutdown_client(f); |
||||
|
||||
grpc_completion_queue_shutdown(f->server_cq); |
||||
drain_cq(f->server_cq); |
||||
grpc_completion_queue_destroy(f->server_cq); |
||||
grpc_completion_queue_shutdown(f->client_cq); |
||||
drain_cq(f->client_cq); |
||||
grpc_completion_queue_destroy(f->client_cq); |
||||
} |
||||
|
||||
/* test the case when there is a pending message at the client side,
|
||||
writes_done should not return a status without a start_read. |
||||
Note: this test will last for 3s. Do not run in a loop. */ |
||||
static void test_writes_done_hangs_with_pending_read( |
||||
grpc_end2end_test_config config) { |
||||
grpc_call *c; |
||||
grpc_call *s; |
||||
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); |
||||
gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); |
||||
grpc_byte_buffer *request_payload = |
||||
grpc_byte_buffer_create(&request_payload_slice, 1); |
||||
grpc_byte_buffer *response_payload = |
||||
grpc_byte_buffer_create(&response_payload_slice, 1); |
||||
gpr_timespec deadline = five_seconds_time(); |
||||
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); |
||||
cq_verifier *v_client = cq_verifier_create(f.client_cq); |
||||
cq_verifier *v_server = cq_verifier_create(f.server_cq); |
||||
|
||||
/* byte buffer holds the slice, we can unref it already */ |
||||
gpr_slice_unref(request_payload_slice); |
||||
gpr_slice_unref(response_payload_slice); |
||||
|
||||
c = grpc_channel_create_call_old(f.client, "/foo", "foo.test.google.fr", |
||||
deadline); |
||||
GPR_ASSERT(c); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_invoke_old(c, f.client_cq, tag(2), tag(3), 0)); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(c, request_payload, tag(4), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(request_payload); |
||||
cq_expect_write_accepted(v_client, tag(4), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call_old(f.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, f.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_read_old(s, tag(5))); |
||||
cq_expect_read(v_server, tag(5), gpr_slice_from_copied_string("hello world")); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == |
||||
grpc_call_start_write_old(s, response_payload, tag(6), 0)); |
||||
/* destroy byte buffer early to ensure async code keeps track of its contents
|
||||
correctly */ |
||||
grpc_byte_buffer_destroy(response_payload); |
||||
cq_expect_write_accepted(v_server, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_server); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_writes_done_old(c, tag(6))); |
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_write_status_old( |
||||
s, GRPC_STATUS_UNIMPLEMENTED, "xyz", tag(7))); |
||||
|
||||
cq_expect_finish_accepted(v_client, tag(6), GRPC_OP_OK); |
||||
cq_verify(v_client); |
||||
|
||||
/* does not return status because there is a pending message to be read */ |
||||
cq_verify_empty(v_client); |
||||
|
||||
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_read_old(c, tag(8))); |
||||
cq_expect_read(v_client, tag(8), gpr_slice_from_copied_string("hello you")); |
||||
cq_verify(v_client); |
||||
|
||||
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(7), GRPC_OP_OK); |
||||
cq_expect_finished(v_server, tag(102), NULL); |
||||
cq_verify(v_server); |
||||
|
||||
grpc_call_destroy(c); |
||||
grpc_call_destroy(s); |
||||
|
||||
end_test(&f); |
||||
config.tear_down_data(&f); |
||||
|
||||
cq_verifier_destroy(v_client); |
||||
cq_verifier_destroy(v_server); |
||||
} |
||||
|
||||
void grpc_end2end_tests(grpc_end2end_test_config config) { |
||||
test_writes_done_hangs_with_pending_read(config); |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
/* This script requires a command line argument, to be used in the "process" |
||||
* probe definition. |
||||
* |
||||
* For a statically build binary, that'd be the name of the binary itself. |
||||
* For dinamically built ones, point to the location of the libgprc.so being |
||||
* used. */ |
||||
|
||||
global starts, times, times_per_tag |
||||
|
||||
probe process(@1).mark("timing_ns_begin") { |
||||
starts[$arg1, tid()] = gettimeofday_ns(); |
||||
} |
||||
|
||||
probe process(@1).mark("timing_ns_end") { |
||||
tag = $arg1 |
||||
t = gettimeofday_ns(); |
||||
if (s = starts[tag, tid()]) { |
||||
times[tag, tid()] <<< t-s; |
||||
delete starts[tag, tid()]; |
||||
} |
||||
} |
||||
|
||||
probe end { |
||||
printf("%15s %9s %10s %10s %10s %10s\n", "tag", "tid", "count", |
||||
"min(ns)", "avg(ns)", "max(ns)"); |
||||
foreach ([tag+, tid] in times) { |
||||
printf("%15X %9d %10d %10d %10d %10d\n", tag, tid, @count(times[tag, tid]), |
||||
@min(times[tag, tid]), @avg(times[tag, tid]), @max(times[tag, tid])); |
||||
} |
||||
|
||||
printf("Per tag average of averages\n"); |
||||
foreach ([tag+, tid] in times) { |
||||
times_per_tag[tag] <<< @avg(times[tag, tid]); |
||||
} |
||||
printf("%15s %10s %10s\n", "tag", "count", "avg(ns)"); |
||||
foreach ([tag+] in times_per_tag) { |
||||
printf("%15X %10d %10d\n", tag, @count(times_per_tag[tag]), |
||||
@avg(times_per_tag[tag])); |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
Loading…
Reference in new issue