From 9f218ddd9db5049d0ba92334f1e0a329171343c9 Mon Sep 17 00:00:00 2001 From: Julien Boeuf Date: Thu, 23 Apr 2015 10:24:02 -0700 Subject: Adding support for per call credentials in core. --- test/core/end2end/end2end_tests.h | 1 + test/core/end2end/fixtures/chttp2_fake_security.c | 4 +- .../end2end/fixtures/chttp2_simple_ssl_fullstack.c | 3 +- .../chttp2_simple_ssl_with_oauth2_fullstack.c | 3 +- test/core/end2end/gen_build_json.py | 66 ++-- .../request_response_with_payload_and_call_creds.c | 338 +++++++++++++++++++++ 6 files changed, 382 insertions(+), 33 deletions(-) create mode 100644 test/core/end2end/tests/request_response_with_payload_and_call_creds.c (limited to 'test/core') diff --git a/test/core/end2end/end2end_tests.h b/test/core/end2end/end2end_tests.h index 41c6e2ee0c..a61c725aa2 100644 --- a/test/core/end2end/end2end_tests.h +++ b/test/core/end2end/end2end_tests.h @@ -41,6 +41,7 @@ typedef struct grpc_end2end_test_config grpc_end2end_test_config; #define FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION 1 #define FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION 2 +#define FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS 4 struct grpc_end2end_test_fixture { grpc_completion_queue *server_cq; diff --git a/test/core/end2end/fixtures/chttp2_fake_security.c b/test/core/end2end/fixtures/chttp2_fake_security.c index 929f1f50db..c1ac9163ed 100644 --- a/test/core/end2end/fixtures/chttp2_fake_security.c +++ b/test/core/end2end/fixtures/chttp2_fake_security.c @@ -112,7 +112,9 @@ static void chttp2_init_server_fake_secure_fullstack( /* All test configurations */ static grpc_end2end_test_config configs[] = { - {"chttp2/fake_secure_fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION, + {"chttp2/fake_secure_fullstack", + FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS, chttp2_create_fixture_secure_fullstack, chttp2_init_client_fake_secure_fullstack, chttp2_init_server_fake_secure_fullstack, diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c index 9c4086d79d..3d6c0cf3f0 100644 --- a/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c +++ b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c @@ -124,7 +124,8 @@ static void chttp2_init_server_simple_ssl_secure_fullstack( static grpc_end2end_test_config configs[] = { {"chttp2/simple_ssl_fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION | - FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION, + FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS, chttp2_create_fixture_secure_fullstack, chttp2_init_client_simple_ssl_secure_fullstack, chttp2_init_server_simple_ssl_secure_fullstack, diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c b/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c index e9e1c5f838..b57872f4f0 100644 --- a/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c +++ b/test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c @@ -129,7 +129,8 @@ static void chttp2_init_server_simple_ssl_secure_fullstack( static grpc_end2end_test_config configs[] = { {"chttp2/simple_ssl_with_oauth2_fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION | - FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION, + FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS, chttp2_create_fixture_secure_fullstack, chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack, chttp2_init_server_simple_ssl_secure_fullstack, diff --git a/test/core/end2end/gen_build_json.py b/test/core/end2end/gen_build_json.py index 1d981cd3ad..c9c2de19f0 100755 --- a/test/core/end2end/gen_build_json.py +++ b/test/core/end2end/gen_build_json.py @@ -46,34 +46,40 @@ END2END_FIXTURES = { 'chttp2_socket_pair_one_byte_at_a_time': False, } -# maps tests names to whether they run fine or not (aka, not flaky) +class TestOptions(object): + def __init__(self, flaky=False, secure=False): + self.flaky = flaky + self.secure = secure + +# maps test names to options END2END_TESTS = { - 'bad_hostname': True, - 'cancel_after_accept': False, - 'cancel_after_accept_and_writes_closed': True, - 'cancel_after_invoke': True, - 'cancel_before_invoke': True, - 'cancel_in_a_vacuum': True, - 'census_simple_request': True, - 'disappearing_server': True, - 'early_server_shutdown_finishes_inflight_calls': True, - 'early_server_shutdown_finishes_tags': True, - 'empty_batch': True, - 'graceful_server_shutdown': True, - 'invoke_large_request': False, - 'max_concurrent_streams': True, - 'max_message_length': True, - 'no_op': True, - 'ping_pong_streaming': True, - 'request_response_with_binary_metadata_and_payload': True, - 'request_response_with_metadata_and_payload': True, - 'request_response_with_payload': True, - 'request_with_large_metadata': True, - 'request_with_payload': True, - 'simple_delayed_request': True, - 'simple_request': True, - 'simple_request_with_high_initial_sequence_number': True, - 'registered_call': True, + 'bad_hostname': TestOptions(), + 'cancel_after_accept': TestOptions(flaky=True), + 'cancel_after_accept_and_writes_closed': TestOptions(), + 'cancel_after_invoke': TestOptions(), + 'cancel_before_invoke': TestOptions(), + 'cancel_in_a_vacuum': TestOptions(), + 'census_simple_request': TestOptions(), + 'disappearing_server': TestOptions(), + 'early_server_shutdown_finishes_inflight_calls': TestOptions(), + 'early_server_shutdown_finishes_tags': TestOptions(), + 'empty_batch': TestOptions(), + 'graceful_server_shutdown': TestOptions(), + 'invoke_large_request': TestOptions(flaky=False), + 'max_concurrent_streams': TestOptions(), + 'max_message_length': TestOptions(), + 'no_op': TestOptions(), + 'ping_pong_streaming': TestOptions(), + 'request_response_with_binary_metadata_and_payload': TestOptions(), + 'request_response_with_metadata_and_payload': TestOptions(), + 'request_response_with_payload': TestOptions(), + 'request_response_with_payload_and_call_creds': TestOptions(secure=True), + 'request_with_large_metadata': TestOptions(), + 'request_with_payload': TestOptions(), + 'simple_delayed_request': TestOptions(), + 'simple_request': TestOptions(), + 'simple_request_with_high_initial_sequence_number': TestOptions(), + 'registered_call': TestOptions(), } @@ -93,7 +99,7 @@ def main(): 'name': 'end2end_test_%s' % t, 'build': 'private', 'language': 'c', - 'secure': 'no', + 'secure': 'check' if END2END_TESTS[t].secure else 'no', 'src': ['test/core/end2end/tests/%s.c' % t], 'headers': ['test/core/end2end/tests/cancel_test_helpers.h'] } @@ -115,7 +121,7 @@ def main(): 'build': 'test', 'language': 'c', 'src': [], - 'flaky': not END2END_TESTS[t], + 'flaky': END2END_TESTS[t].flaky, 'deps': [ 'end2end_fixture_%s' % f, 'end2end_test_%s' % t, @@ -145,7 +151,7 @@ def main(): ] } for f in sorted(END2END_FIXTURES.keys()) if not END2END_FIXTURES[f] - for t in sorted(END2END_TESTS.keys())]} + for t in sorted(END2END_TESTS.keys()) if not END2END_TESTS[t].secure]} print simplejson.dumps(json, sort_keys=True, indent=2 * ' ') diff --git a/test/core/end2end/tests/request_response_with_payload_and_call_creds.c b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c new file mode 100644 index 0000000000..399a4843bd --- /dev/null +++ b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c @@ -0,0 +1,338 @@ +/* + * + * 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include "test/core/end2end/cq_verifier.h" +#include "src/core/security/credentials.h" +#include "src/core/support/string.h" + +static const char iam_token[] = "token"; +static const char iam_selector[] = "selector"; +static const char overridden_iam_token[] = "overridden_token"; +static const char overridden_iam_selector[] = "overridden_selector"; + +typedef enum { + NONE, + OVERRIDE, + DELETE +} override_mode; + +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_call_creds_failure(grpc_end2end_test_config config) { + grpc_call *c; + grpc_credentials *creds = NULL; + grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL); + gpr_timespec deadline = five_seconds_time(); + c = grpc_channel_create_call(f.client, f.client_cq, "/foo", + "foo.test.google.fr", deadline); + GPR_ASSERT(c); + + /* Try with credentials unfit to be set on a call (channel creds). */ + creds = grpc_fake_transport_security_credentials_create(); + GPR_ASSERT(grpc_call_set_credentials(c, creds) != GRPC_CALL_OK); + grpc_credentials_release(creds); + + end_test(&f); + config.tear_down_data(&f); +} + +static void request_response_with_payload_and_call_creds( + const char *test_name, grpc_end2end_test_config config, + override_mode mode) { + 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, test_name, NULL, NULL); + cq_verifier *v_client = cq_verifier_create(f.client_cq); + cq_verifier *v_server = cq_verifier_create(f.server_cq); + grpc_op ops[6]; + grpc_op *op; + grpc_metadata_array initial_metadata_recv; + grpc_metadata_array trailing_metadata_recv; + grpc_metadata_array request_metadata_recv; + grpc_byte_buffer *request_payload_recv = NULL; + grpc_byte_buffer *response_payload_recv = NULL; + grpc_call_details call_details; + grpc_status_code status; + char *details = NULL; + size_t details_capacity = 0; + int was_cancelled = 2; + grpc_credentials *creds = NULL; + + c = grpc_channel_create_call(f.client, f.client_cq, "/foo", + "foo.test.google.fr", deadline); + GPR_ASSERT(c); + creds = grpc_iam_credentials_create(iam_token, iam_selector); + GPR_ASSERT(creds != NULL); + GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK); + switch (mode) { + case NONE: + break; + case OVERRIDE: + grpc_credentials_release(creds); + creds = grpc_iam_credentials_create(overridden_iam_token, + overridden_iam_selector); + GPR_ASSERT(creds != NULL); + GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK); + break; + case DELETE: + GPR_ASSERT(grpc_call_set_credentials(c, NULL) == GRPC_CALL_OK); + break; + } + grpc_credentials_release(creds); + + grpc_metadata_array_init(&initial_metadata_recv); + grpc_metadata_array_init(&trailing_metadata_recv); + grpc_metadata_array_init(&request_metadata_recv); + grpc_call_details_init(&call_details); + + op = ops; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = 0; + op++; + op->op = GRPC_OP_SEND_MESSAGE; + op->data.send_message = request_payload; + op++; + op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op++; + op->op = GRPC_OP_RECV_INITIAL_METADATA; + op->data.recv_initial_metadata = &initial_metadata_recv; + op++; + op->op = GRPC_OP_RECV_MESSAGE; + op->data.recv_message = &response_payload_recv; + op++; + op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; + op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; + op->data.recv_status_on_client.status = &status; + op->data.recv_status_on_client.status_details = &details; + op->data.recv_status_on_client.status_details_capacity = &details_capacity; + op++; + GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, op - ops, tag(1))); + + GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(f.server, &s, + &call_details, + &request_metadata_recv, + f.server_cq, tag(101))); + cq_expect_completion(v_server, tag(101), GRPC_OP_OK); + cq_verify(v_server); + + /* Cannot set creds on the server call object. */ + GPR_ASSERT(grpc_call_set_credentials(s, NULL) != GRPC_CALL_OK); + + op = ops; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = 0; + op++; + op->op = GRPC_OP_SEND_MESSAGE; + op->data.send_message = response_payload; + op++; + op->op = GRPC_OP_SEND_STATUS_FROM_SERVER; + op->data.send_status_from_server.trailing_metadata_count = 0; + op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED; + op->data.send_status_from_server.status_details = "xyz"; + op++; + op->op = GRPC_OP_RECV_MESSAGE; + op->data.recv_message = &request_payload_recv; + op++; + op->op = GRPC_OP_RECV_CLOSE_ON_SERVER; + op->data.recv_close_on_server.cancelled = &was_cancelled; + op++; + GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(s, ops, op - ops, tag(102))); + + cq_expect_completion(v_server, tag(102), GRPC_OP_OK); + cq_verify(v_server); + + cq_expect_completion(v_client, tag(1), GRPC_OP_OK); + cq_verify(v_client); + + GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED); + GPR_ASSERT(0 == strcmp(details, "xyz")); + GPR_ASSERT(0 == strcmp(call_details.method, "/foo")); + GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr")); + GPR_ASSERT(was_cancelled == 0); + GPR_ASSERT(byte_buffer_eq_string(request_payload_recv, "hello world")); + GPR_ASSERT(byte_buffer_eq_string(response_payload_recv, "hello you")); + + switch (mode) { + case NONE: + GPR_ASSERT(contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, + iam_token)); + GPR_ASSERT(contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, + iam_selector)); + break; + case OVERRIDE: + GPR_ASSERT(contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, + overridden_iam_token)); + GPR_ASSERT(contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, + overridden_iam_selector)); + break; + case DELETE: + GPR_ASSERT(!contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, + iam_token)); + GPR_ASSERT(!contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, + iam_selector)); + GPR_ASSERT(!contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, + overridden_iam_token)); + GPR_ASSERT(!contains_metadata(&request_metadata_recv, + GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, + overridden_iam_selector)); + break; + } + + gpr_free(details); + grpc_metadata_array_destroy(&initial_metadata_recv); + grpc_metadata_array_destroy(&trailing_metadata_recv); + grpc_metadata_array_destroy(&request_metadata_recv); + grpc_call_details_destroy(&call_details); + + grpc_call_destroy(c); + grpc_call_destroy(s); + + cq_verifier_destroy(v_client); + cq_verifier_destroy(v_server); + + grpc_byte_buffer_destroy(request_payload); + grpc_byte_buffer_destroy(response_payload); + grpc_byte_buffer_destroy(request_payload_recv); + grpc_byte_buffer_destroy(response_payload_recv); + + end_test(&f); + config.tear_down_data(&f); +} + +void test_request_response_with_payload_and_call_creds( + grpc_end2end_test_config config) { + request_response_with_payload_and_call_creds(__FUNCTION__, config, NONE); +} + +void test_request_response_with_payload_and_overridden_call_creds( + grpc_end2end_test_config config) { + request_response_with_payload_and_call_creds(__FUNCTION__, config, OVERRIDE); +} + +void test_request_response_with_payload_and_deleted_call_creds( + grpc_end2end_test_config config) { + request_response_with_payload_and_call_creds(__FUNCTION__, config, DELETE); +} + +void grpc_end2end_tests(grpc_end2end_test_config config) { + if (config.feature_mask & FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS) { + test_call_creds_failure(config); + test_request_response_with_payload_and_call_creds(config); + test_request_response_with_payload_and_overridden_call_creds(config); + test_request_response_with_payload_and_deleted_call_creds(config); + } +} + -- cgit v1.2.3