aws_http_connection_is_open() (#29)

- Added `aws_http_connection_is_open()`
- Modified `aws_http_connection_close()` so it made the connection **immediately not open**, even if called from outside the event-loop thread.

Author: graebm

include/aws/http/connection.h

@@ -143,6 +143,12 @@ void aws_http_connection_release(struct aws_http_connection *connection);
 AWS_HTTP_API
 void aws_http_connection_close(struct aws_http_connection *connection);
 
+/**
+ * Returns true unless the connection is closed or closing.
+ */
+AWS_HTTP_API
+bool aws_http_connection_is_open(const struct aws_http_connection *connection);
+
 AWS_HTTP_API
 enum aws_http_version aws_http_connection_get_version(const struct aws_http_connection *connection);
 

include/aws/http/private/connection_impl.h

@@ -46,6 +46,7 @@ struct aws_http_connection_vtable {
 
     struct aws_http_stream *(*new_client_request_stream)(const struct aws_http_request_options *options);
     void (*close)(struct aws_http_connection *connection);
+    bool (*is_open)(const struct aws_http_connection *connection);
 };
 
 /**

source/connection.c

@@ -174,6 +174,11 @@ void aws_http_connection_close(struct aws_http_connection *connection) {
     connection->vtable->close(connection);
 }
 
+bool aws_http_connection_is_open(const struct aws_http_connection *connection) {
+    assert(connection);
+    return connection->vtable->is_open(connection);
+}
+
 void aws_http_connection_release(struct aws_http_connection *connection) {
     assert(connection);
     size_t prev_refcount = aws_atomic_fetch_sub(&connection->refcount, 1);

source/connection_h1.c

@@ -60,6 +60,7 @@ static size_t s_handler_message_overhead(struct aws_channel_handler *handler);
 static void s_handler_destroy(struct aws_channel_handler *handler);
 static struct aws_http_stream *s_new_client_request_stream(const struct aws_http_request_options *options);
 static void s_connection_close(struct aws_http_connection *connection_base);
+static bool s_connection_is_open(const struct aws_http_connection *connection_base);
 static void s_stream_destroy(struct aws_http_stream *stream_base);
 static void s_stream_update_window(struct aws_http_stream *stream, size_t increment_size);
 static int s_decoder_on_request(
@@ -86,6 +87,7 @@ static struct aws_http_connection_vtable s_connection_vtable = {
 
     .new_client_request_stream = s_new_client_request_stream,
     .close = s_connection_close,
+    .is_open = s_connection_is_open,
 };
 
 static const struct aws_http_stream_vtable s_stream_vtable = {
@@ -189,32 +191,41 @@ struct h1_stream {
 
 /**
  * Internal function for shutting down the connection.
- * If connection is already shutting down, this call has no effect.
+ * This function can be called multiple times, from on-thread or off.
+ * This function is always run once on-thread during channel shutdown.
  */
 static void s_shutdown_connection(struct h1_connection *connection, int error_code) {
-    assert(aws_channel_thread_is_callers_thread(connection->base.channel_slot->channel));
+    bool on_thread = aws_channel_thread_is_callers_thread(connection->base.channel_slot->channel);
+    if (on_thread) {
+        /* If thread_data already knew about shutdown, then no more work to do here. */
+        if (connection->thread_data.is_shutting_down) {
+            return;
+        }
 
-    if (!connection->thread_data.is_shutting_down) {
+        connection->thread_data.is_shutting_down = true;
+        connection->thread_data.shutdown_error_code = error_code;
+    }
+
+    bool was_shutdown_known;
+    { /* BEGIN CRITICAL SECTION */
+        int err = aws_mutex_lock(&connection->synced_data.lock);
+        AWS_FATAL_ASSERT(!err);
+
+        was_shutdown_known = connection->synced_data.is_shutting_down;
+        connection->synced_data.is_shutting_down = true;
+
+        err = aws_mutex_unlock(&connection->synced_data.lock);
+        AWS_FATAL_ASSERT(!err);
+    } /* END CRITICAL SECTION */
+
+    if (!was_shutdown_known) {
         AWS_LOGF_INFO(
             AWS_LS_HTTP_CONNECTION,
             "id=%p: Connection shutting down with error code %d (%s).",
             (void *)&connection->base,
             error_code,
             aws_error_name(error_code));
 
-        { /* BEGIN CRITICAL SECTION */
-            int err = aws_mutex_lock(&connection->synced_data.lock);
-            AWS_FATAL_ASSERT(!err);
-
-            connection->synced_data.is_shutting_down = true;
-
-            err = aws_mutex_unlock(&connection->synced_data.lock);
-            AWS_FATAL_ASSERT(!err);
-        } /* END CRITICAL SECTION */
-
-        connection->thread_data.is_shutting_down = true;
-        connection->thread_data.shutdown_error_code = error_code;
-
         /* Delay the call to aws_channel_shutdown().
          * This ensures that a user calling aws_http_connection_close() won't have completion callbacks
          * firing before aws_http_connection_close() has even returned. */
@@ -234,18 +245,27 @@ static void s_shutdown_delay_task(struct aws_channel_task *task, void *arg, enum
 
 /**
  * Public function for closing connection.
- * If connection is already shutting down, this call has no effect.
  */
 static void s_connection_close(struct aws_http_connection *connection_base) {
     struct h1_connection *connection = AWS_CONTAINER_OF(connection_base, struct h1_connection, base);
+    s_shutdown_connection(connection, AWS_ERROR_SUCCESS);
+}
 
-    if (aws_channel_thread_is_callers_thread(connection_base->channel_slot->channel)) {
-        /* Invoke internal function so connection ceases work immediately */
-        s_shutdown_connection(connection, AWS_ERROR_SUCCESS);
-    } else {
-        /* Not on thread, so tell channel to shut down, which will result in connection shutting down. */
-        aws_channel_shutdown(connection_base->channel_slot->channel, AWS_ERROR_SUCCESS);
-    }
+static bool s_connection_is_open(const struct aws_http_connection *connection_base) {
+    struct h1_connection *connection = AWS_CONTAINER_OF(connection_base, struct h1_connection, base);
+    bool is_shutting_down;
+
+    { /* BEGIN CRITICAL SECTION */
+        int err = aws_mutex_lock(&connection->synced_data.lock);
+        AWS_FATAL_ASSERT(!err);
+
+        is_shutting_down = connection->synced_data.is_shutting_down;
+
+        err = aws_mutex_unlock(&connection->synced_data.lock);
+        AWS_FATAL_ASSERT(!err);
+    } /* END CRITICAL SECTION */
+
+    return !is_shutting_down;
 }
 
 /**

tests/CMakeLists.txt

@@ -49,6 +49,8 @@ add_test_case(h1_client_close_from_incoming_headers_callback_stops_decoder)
 add_test_case(h1_client_close_from_incoming_headers_done_callback_stops_decoder)
 add_test_case(h1_client_close_from_incoming_body_callback_stops_decoder)
 add_test_case(h1_client_close_from_stream_complete_callback_stops_decoder)
+add_test_case(h1_client_close_from_off_thread_makes_not_open)
+add_test_case(h1_client_close_from_on_thread_makes_not_open)
 
 set(TEST_BINARY_NAME ${CMAKE_PROJECT_NAME}-tests)
 generate_test_driver(${TEST_BINARY_NAME})

tests/test_h1_client.c

@@ -1290,6 +1290,45 @@ H1_CLIENT_TEST_CASE(h1_client_close_from_stream_complete_callback_stops_decoder)
     return AWS_OP_SUCCESS;
 }
 
+/* After aws_http_connection_close() is called, aws_http_connection_is_open() should return false,
+ * even if both calls were made from outside the event-loop thread. */
+H1_CLIENT_TEST_CASE(h1_client_close_from_off_thread_makes_not_open) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, false);
+
+    ASSERT_TRUE(aws_http_connection_is_open(tester.connection));
+    aws_http_connection_close(tester.connection);
+    ASSERT_FALSE(aws_http_connection_is_open(tester.connection));
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, true);
+
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}
+
+H1_CLIENT_TEST_CASE(h1_client_close_from_on_thread_makes_not_open) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, false);
+    ASSERT_TRUE(aws_http_connection_is_open(tester.connection));
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, true);
+    aws_http_connection_close(tester.connection);
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, false);
+    ASSERT_FALSE(aws_http_connection_is_open(tester.connection));
+
+    testing_channel_set_is_on_users_thread(&tester.testing_channel, true);
+
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}
+
 /* Tests TODO
 -   Responses
     -   Responses finishing before request done sending