aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-http/source/hpack.c

@@ -13,6 +13,8 @@
 #include <aws/common/logging.h>
 #include <aws/common/string.h>
 
+#include <inttypes.h>
+
 /* #TODO split hpack encoder/decoder into different types */
 
 /* #TODO test empty strings */
@@ -238,6 +240,7 @@ struct aws_hpack_context {
         size_t size;
         size_t max_size;
 
+        /* TODO: check the new (RFC 9113 - 4.3.1) to make sure we did it right */
         /* SETTINGS_HEADER_TABLE_SIZE from http2 */
         size_t protocol_max_size_setting;
         /* aws_http_header * -> size_t */

data/aws-crt-ffi/crt/aws-c-http/source/http.c

@@ -318,6 +318,9 @@ static void s_headers_init(struct aws_allocator *alloc) {
     s_header_enum_to_str[AWS_HTTP_HEADER_RETRY_AFTER] = aws_byte_cursor_from_c_str("retry-after");
     s_header_enum_to_str[AWS_HTTP_HEADER_VARY] = aws_byte_cursor_from_c_str("vary");
     s_header_enum_to_str[AWS_HTTP_HEADER_WARNING] = aws_byte_cursor_from_c_str("warning");
+    s_header_enum_to_str[AWS_HTTP_HEADER_UPGRADE] = aws_byte_cursor_from_c_str("upgrade");
+    s_header_enum_to_str[AWS_HTTP_HEADER_KEEP_ALIVE] = aws_byte_cursor_from_c_str("keep-alive");
+    s_header_enum_to_str[AWS_HTTP_HEADER_PROXY_CONNECTION] = aws_byte_cursor_from_c_str("proxy-connection");
 
     s_init_str_to_enum_hash_table(
         &s_header_str_to_enum,

data/aws-crt-ffi/crt/aws-c-http/source/http2_stream_manager.c

@@ -4,6 +4,7 @@
  */
 
 #include <aws/common/array_list.h>
+#include <aws/common/clock.h>
 #include <aws/common/hash_table.h>
 #include <aws/common/logging.h>
 #include <aws/http/connection.h>
@@ -16,6 +17,7 @@
 #include <aws/http/http2_stream_manager.h>
 #include <aws/http/private/http2_stream_manager_impl.h>
 #include <aws/http/private/request_response_impl.h>
+#include <aws/http/status_code.h>
 
 #include <inttypes.h>
 
@@ -30,6 +32,9 @@
     AWS_LOGF_##level(AWS_LS_HTTP_STREAM_MANAGER, "id=%p: " text, (void *)(stream_manager), __VA_ARGS__)
 #define STREAM_MANAGER_LOG(level, stream_manager, text) STREAM_MANAGER_LOGF(level, stream_manager, "%s", text)
 
+/* 3 seconds */
+static const size_t s_default_ping_timeout_ms = 3000;
+
 static void s_stream_manager_start_destroy(struct aws_http2_stream_manager *stream_manager);
 static void s_aws_http2_stream_manager_build_transaction_synced(struct aws_http2_stream_management_transaction *work);
 static void s_aws_http2_stream_manager_execute_transaction(struct aws_http2_stream_management_transaction *work);
@@ -98,7 +103,6 @@ static void s_sm_count_increase_synced(
     for (size_t i = 0; i < num; i++) {
         aws_ref_count_acquire(&stream_manager->internal_ref_count);
     }
-    s_sm_log_stats_synced(stream_manager);
 }
 
 static void s_sm_count_decrease_synced(
@@ -109,15 +113,12 @@ static void s_sm_count_decrease_synced(
     for (size_t i = 0; i < num; i++) {
         aws_ref_count_release(&stream_manager->internal_ref_count);
     }
-    s_sm_log_stats_synced(stream_manager);
 }
 
 static void s_aws_stream_management_transaction_init(
     struct aws_http2_stream_management_transaction *work,
     struct aws_http2_stream_manager *stream_manager) {
     AWS_ZERO_STRUCT(*work);
-
-    STREAM_MANAGER_LOGF(TRACE, stream_manager, "work:%p inits", (void *)work);
     aws_linked_list_init(&work->pending_make_requests);
     work->stream_manager = stream_manager;
     work->allocator = stream_manager->allocator;
@@ -126,7 +127,6 @@ static void s_aws_stream_management_transaction_init(
 
 static void s_aws_stream_management_transaction_clean_up(struct aws_http2_stream_management_transaction *work) {
     (void)work;
-    STREAM_MANAGER_LOGF(TRACE, work->stream_manager, "work:%p clean up", (void *)work);
     AWS_ASSERT(aws_linked_list_empty(&work->pending_make_requests));
     aws_ref_count_release(&work->stream_manager->internal_ref_count);
 }
@@ -142,11 +142,12 @@ static struct aws_h2_sm_connection *s_get_best_sm_connection_from_set(struct aws
         sm_connection_a->num_streams_assigned > sm_connection_b->num_streams_assigned ? sm_connection_b
                                                                                       : sm_connection_a;
     return errored == AWS_ERROR_SUCCESS ? chosen_connection : NULL;
+    (void)errored;
 }
 
 /* helper function for building the transaction: Try to assign connection for a pending stream acquisition */
 /* *_synced should only be called with LOCK HELD or from another synced function */
-static void s_sm_try_assign_connection_to_pending_stream_acquisition(
+static void s_sm_try_assign_connection_to_pending_stream_acquisition_synced(
     struct aws_http2_stream_manager *stream_manager,
     struct aws_h2_sm_pending_stream_acquisition *pending_stream_acquisition) {
 
@@ -163,7 +164,7 @@ static void s_sm_try_assign_connection_to_pending_stream_acquisition(
         chosen_connection->num_streams_assigned++;
 
         STREAM_MANAGER_LOGF(
-            TRACE,
+            DEBUG,
             stream_manager,
             "Picking connection:%p for acquisition:%p. Streams assigned to the connection=%" PRIu32 "",
             (void *)chosen_connection->connection,
@@ -215,7 +216,7 @@ static void s_sm_try_assign_connection_to_pending_stream_acquisition(
             chosen_connection->num_streams_assigned++;
 
             STREAM_MANAGER_LOGF(
-                TRACE,
+                DEBUG,
                 stream_manager,
                 "Picking connection:%p for acquisition:%p. Streams assigned to the connection=%" PRIu32 "",
                 (void *)chosen_connection->connection,
@@ -239,6 +240,7 @@ static void s_sm_try_assign_connection_to_pending_stream_acquisition(
         }
     }
     AWS_ASSERT(errored == 0 && "random access set went wrong");
+    (void)errored;
 }
 
 /* NOTE: never invoke with lock held */
@@ -312,14 +314,14 @@ static void s_check_new_connections_needed_synced(struct aws_http2_stream_manage
         ideal_new_connection_count,
         stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_CONNECTIONS_ACQUIRING]);
     /* The real number we can have is the min of how many more we can still have and how many we need */
-    size_t new_connections_avaliable =
+    size_t new_connections_available =
         stream_manager->max_connections - stream_manager->synced_data.holding_connections_count -
         stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_CONNECTIONS_ACQUIRING];
-    work->new_connections = aws_min_size(new_connections_avaliable, work->new_connections);
+    work->new_connections = aws_min_size(new_connections_available, work->new_connections);
     /* Update the number of connections we acquiring */
     s_sm_count_increase_synced(stream_manager, AWS_SMCT_CONNECTIONS_ACQUIRING, work->new_connections);
     STREAM_MANAGER_LOGF(
-        TRACE,
+        DEBUG,
         stream_manager,
         "number of acquisition that waiting for connections to use=%zu. connection acquiring=%zu, connection held=%zu, "
         "max connection=%zu",
@@ -347,12 +349,12 @@ static void s_aws_http2_stream_manager_build_transaction_synced(struct aws_http2
                 aws_linked_list_pop_front(&stream_manager->synced_data.pending_stream_acquisitions);
             struct aws_h2_sm_pending_stream_acquisition *pending_stream_acquisition =
                 AWS_CONTAINER_OF(node, struct aws_h2_sm_pending_stream_acquisition, node);
-            s_sm_try_assign_connection_to_pending_stream_acquisition(stream_manager, pending_stream_acquisition);
+            s_sm_try_assign_connection_to_pending_stream_acquisition_synced(stream_manager, pending_stream_acquisition);
             if (pending_stream_acquisition->sm_connection == NULL) {
                 /* Cannot find any connection, push it back to the front and break the loop */
                 aws_linked_list_push_front(&stream_manager->synced_data.pending_stream_acquisitions, node);
                 STREAM_MANAGER_LOGF(
-                    TRACE,
+                    DEBUG,
                     stream_manager,
                     "acquisition:%p cannot find any connection to use.",
                     (void *)pending_stream_acquisition);
@@ -390,6 +392,111 @@ static void s_aws_http2_stream_manager_build_transaction_synced(struct aws_http2
             stream_manager->synced_data.finish_pending_stream_acquisitions_task_scheduled = true;
         }
     }
+    s_sm_log_stats_synced(stream_manager);
+}
+
+static void s_on_ping_complete(
+    struct aws_http_connection *http2_connection,
+    uint64_t round_trip_time_ns,
+    int error_code,
+    void *user_data) {
+
+    (void)http2_connection;
+    struct aws_h2_sm_connection *sm_connection = user_data;
+    if (error_code) {
+        goto done;
+    }
+    if (!sm_connection->connection) {
+        goto done;
+    }
+    AWS_ASSERT(aws_channel_thread_is_callers_thread(aws_http_connection_get_channel(sm_connection->connection)));
+    STREAM_MANAGER_LOGF(
+        TRACE,
+        sm_connection->stream_manager,
+        "PING ACK received for connection: %p. Round trip time in ns is: %" PRIu64 ".",
+        (void *)sm_connection->connection,
+        round_trip_time_ns);
+    sm_connection->thread_data.ping_received = true;
+
+done:
+    /* Release refcount held for ping complete */
+    aws_ref_count_release(&sm_connection->ref_count);
+}
+
+static void s_connection_ping_timeout_task(struct aws_channel_task *task, void *arg, enum aws_task_status status) {
+    (void)task;
+    (void)status;
+    struct aws_h2_sm_connection *sm_connection = arg;
+    if (status != AWS_TASK_STATUS_RUN_READY) {
+        goto done;
+    }
+    if (!sm_connection->connection) {
+        /* The connection has been released before timeout happens, just release the refcount */
+        goto done;
+    }
+    AWS_ASSERT(aws_channel_thread_is_callers_thread(aws_http_connection_get_channel(sm_connection->connection)));
+    if (!sm_connection->thread_data.ping_received) {
+        /* Timeout happened */
+        STREAM_MANAGER_LOGF(
+            ERROR,
+            sm_connection->stream_manager,
+            "ping timeout detected for connection: %p, closing connection.",
+            (void *)sm_connection->connection);
+
+        aws_http_connection_close(sm_connection->connection);
+    } else {
+        struct aws_channel *channel = aws_http_connection_get_channel(sm_connection->connection);
+        /* acquire a refcount for next set of tasks to run */
+        aws_ref_count_acquire(&sm_connection->ref_count);
+        aws_channel_schedule_task_future(
+            channel, &sm_connection->ping_task, sm_connection->thread_data.next_ping_task_time);
+    }
+done:
+    /* Release refcount for current set of tasks */
+    aws_ref_count_release(&sm_connection->ref_count);
+}
+
+static void s_connection_ping_task(struct aws_channel_task *task, void *arg, enum aws_task_status status) {
+    (void)task;
+    (void)status;
+    struct aws_h2_sm_connection *sm_connection = arg;
+    if (status != AWS_TASK_STATUS_RUN_READY) {
+        aws_ref_count_release(&sm_connection->ref_count);
+        return;
+    }
+    if (!sm_connection->connection) {
+        /* The connection has been released before ping task, just release the refcount */
+        aws_ref_count_release(&sm_connection->ref_count);
+        return;
+    }
+    AWS_ASSERT(aws_channel_thread_is_callers_thread(aws_http_connection_get_channel(sm_connection->connection)));
+
+    STREAM_MANAGER_LOGF(
+        TRACE, sm_connection->stream_manager, "Sending PING for connection: %p.", (void *)sm_connection->connection);
+    aws_http2_connection_ping(sm_connection->connection, NULL, s_on_ping_complete, sm_connection);
+    /* Acquire refcount for PING complete to be invoked. */
+    aws_ref_count_acquire(&sm_connection->ref_count);
+    sm_connection->thread_data.ping_received = false;
+
+    /* schedule timeout task */
+    struct aws_channel *channel = aws_http_connection_get_channel(sm_connection->connection);
+    uint64_t current_time = 0;
+    aws_channel_current_clock_time(channel, &current_time);
+    sm_connection->thread_data.next_ping_task_time =
+        current_time + sm_connection->stream_manager->connection_ping_period_ns;
+    uint64_t timeout_time = current_time + sm_connection->stream_manager->connection_ping_timeout_ns;
+    aws_channel_task_init(
+        &sm_connection->ping_timeout_task,
+        s_connection_ping_timeout_task,
+        sm_connection,
+        "Stream manager connection ping timeout task");
+    /* keep the refcount for timeout task to run */
+    aws_channel_schedule_task_future(channel, &sm_connection->ping_timeout_task, timeout_time);
+}
+
+static void s_sm_connection_destroy(void *user_data) {
+    struct aws_h2_sm_connection *sm_connection = user_data;
+    aws_mem_release(sm_connection->allocator, sm_connection);
 }
 
 static struct aws_h2_sm_connection *s_sm_connection_new(
@@ -397,6 +504,7 @@ static struct aws_h2_sm_connection *s_sm_connection_new(
     struct aws_http_connection *connection) {
     struct aws_h2_sm_connection *sm_connection =
         aws_mem_calloc(stream_manager->allocator, 1, sizeof(struct aws_h2_sm_connection));
+    sm_connection->allocator = stream_manager->allocator;
     /* Max concurrent stream reached, we need to update the max for the sm_connection */
     struct aws_http2_setting out_settings[AWS_HTTP2_SETTINGS_COUNT];
     /* The setting id equals to the index plus one. */
@@ -407,16 +515,33 @@ static struct aws_h2_sm_connection *s_sm_connection_new(
     sm_connection->connection = connection;
     sm_connection->stream_manager = stream_manager;
     sm_connection->state = AWS_H2SMCST_IDEAL;
+    aws_ref_count_init(&sm_connection->ref_count, sm_connection, s_sm_connection_destroy);
+    if (stream_manager->connection_ping_period_ns) {
+        struct aws_channel *channel = aws_http_connection_get_channel(connection);
+        uint64_t schedule_time = 0;
+        aws_channel_current_clock_time(channel, &schedule_time);
+        schedule_time += stream_manager->connection_ping_period_ns;
+        aws_channel_task_init(
+            &sm_connection->ping_task, s_connection_ping_task, sm_connection, "Stream manager connection ping task");
+        /* Keep a refcount on sm_connection for the task to run. */
+        aws_ref_count_acquire(&sm_connection->ref_count);
+        aws_channel_schedule_task_future(channel, &sm_connection->ping_task, schedule_time);
+    }
     return sm_connection;
 }
 
-void s_sm_connection_destroy(struct aws_h2_sm_connection *sm_connection) {
+static void s_sm_connection_release_connection(struct aws_h2_sm_connection *sm_connection) {
     AWS_ASSERT(sm_connection->num_streams_assigned == 0);
     if (sm_connection->connection) {
-        aws_http_connection_manager_release_connection(
+        /* Should only be invoked from the connection thread. */
+        AWS_ASSERT(aws_channel_thread_is_callers_thread(aws_http_connection_get_channel(sm_connection->connection)));
+        int error = aws_http_connection_manager_release_connection(
             sm_connection->stream_manager->connection_manager, sm_connection->connection);
+        AWS_ASSERT(!error);
+        (void)error;
+        sm_connection->connection = NULL;
     }
-    aws_mem_release(sm_connection->stream_manager->allocator, sm_connection);
+    aws_ref_count_release(&sm_connection->ref_count);
 }
 
 static void s_sm_on_connection_acquired_failed_synced(
@@ -445,6 +570,7 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
     STREAM_MANAGER_LOGF(TRACE, stream_manager, "connection=%p acquired from connection manager", (void *)connection);
     int re_error = 0;
     int stream_fail_error_code = AWS_ERROR_SUCCESS;
+    bool should_release_connection = false;
     struct aws_linked_list stream_acquisitions_to_fail;
     aws_linked_list_init(&stream_acquisitions_to_fail);
     s_aws_stream_management_transaction_init(&work, stream_manager);
@@ -453,7 +579,7 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
         s_sm_count_decrease_synced(stream_manager, AWS_SMCT_CONNECTIONS_ACQUIRING, 1);
         if (error_code || !connection) {
             STREAM_MANAGER_LOGF(
-                WARN,
+                ERROR,
                 stream_manager,
                 "connection acquired from connection manager failed, with error: %d(%s)",
                 error_code,
@@ -466,7 +592,7 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
                 stream_manager,
                 "Unexpected HTTP version acquired, release the connection=%p acquired immediately",
                 (void *)connection);
-            re_error |= aws_http_connection_manager_release_connection(stream_manager->connection_manager, connection);
+            should_release_connection = true;
             s_sm_on_connection_acquired_failed_synced(stream_manager, &stream_acquisitions_to_fail);
             stream_fail_error_code = AWS_ERROR_HTTP_STREAM_MANAGER_UNEXPECTED_HTTP_VERSION;
         } else if (stream_manager->synced_data.state != AWS_H2SMST_READY) {
@@ -476,7 +602,7 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
                 "shutting down, release the connection=%p acquired immediately",
                 (void *)connection);
             /* Release the acquired connection */
-            re_error |= aws_http_connection_manager_release_connection(stream_manager->connection_manager, connection);
+            should_release_connection = true;
         } else if (stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_PENDING_ACQUISITION] == 0) {
             STREAM_MANAGER_LOGF(
                 DEBUG,
@@ -484,7 +610,7 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
                 "No pending acquisition, release the connection=%p acquired immediately",
                 (void *)connection);
             /* Release the acquired connection */
-            re_error |= aws_http_connection_manager_release_connection(stream_manager->connection_manager, connection);
+            should_release_connection = true;
         } else {
             struct aws_h2_sm_connection *sm_connection = s_sm_connection_new(stream_manager, connection);
             bool added = false;
@@ -497,7 +623,14 @@ static void s_sm_on_connection_acquired(struct aws_http_connection *connection,
         s_unlock_synced_data(stream_manager);
     } /* END CRITICAL SECTION */
 
+    if (should_release_connection) {
+        STREAM_MANAGER_LOGF(DEBUG, stream_manager, "Releasing connection: %p", (void *)connection);
+        re_error |= aws_http_connection_manager_release_connection(stream_manager->connection_manager, connection);
+    }
+
     AWS_ASSERT(!re_error && "connection acquired callback fails with programming errors");
+    (void)re_error;
+
     /* Fail acquisitions if any */
     s_finish_pending_stream_acquisitions_list_helper(
         stream_manager, &stream_acquisitions_to_fail, stream_fail_error_code);
@@ -511,10 +644,40 @@ static int s_on_incoming_headers(
     size_t num_headers,
     void *user_data) {
     struct aws_h2_sm_pending_stream_acquisition *pending_stream_acquisition = user_data;
+    struct aws_h2_sm_connection *sm_connection = pending_stream_acquisition->sm_connection;
+    struct aws_http2_stream_manager *stream_manager = sm_connection->stream_manager;
+
     if (pending_stream_acquisition->options.on_response_headers) {
         return pending_stream_acquisition->options.on_response_headers(
             stream, header_block, header_array, num_headers, pending_stream_acquisition->options.user_data);
     }
+    if (stream_manager->close_connection_on_server_error) {
+        /* Check status code if stream completed successfully. */
+        int status_code = 0;
+        aws_http_stream_get_incoming_response_status(stream, &status_code);
+        AWS_ASSERT(status_code != 0); /* The get status should not fail */
+        switch (status_code) {
+            case AWS_HTTP_STATUS_CODE_500_INTERNAL_SERVER_ERROR:
+            case AWS_HTTP_STATUS_CODE_502_BAD_GATEWAY:
+            case AWS_HTTP_STATUS_CODE_503_SERVICE_UNAVAILABLE:
+            case AWS_HTTP_STATUS_CODE_504_GATEWAY_TIMEOUT:
+                /* For those error code if the retry happens, it should not use the same connection. */
+                if (!sm_connection->thread_data.stopped_new_requests) {
+                    STREAM_MANAGER_LOGF(
+                        DEBUG,
+                        stream_manager,
+                        "no longer using connection: %p due to receiving %d server error status code for stream: %p",
+                        (void *)sm_connection->connection,
+                        status_code,
+                        (void *)stream);
+                    aws_http_connection_stop_new_requests(sm_connection->connection);
+                    sm_connection->thread_data.stopped_new_requests = true;
+                }
+                break;
+            default:
+                break;
+        }
+    }
     return AWS_OP_SUCCESS;
 }
 
@@ -539,7 +702,7 @@ static int s_on_incoming_body(struct aws_http_stream *stream, const struct aws_b
     return AWS_OP_SUCCESS;
 }
 
-/* Helper invoked when underlying connections is still aviable and the num stream assigned has been updated */
+/* Helper invoked when underlying connections is still available and the num stream assigned has been updated */
 static void s_update_sm_connection_set_on_stream_finishes_synced(
     struct aws_h2_sm_connection *sm_connection,
     struct aws_http2_stream_manager *stream_manager) {
@@ -593,6 +756,7 @@ static void s_update_sm_connection_set_on_stream_finishes_synced(
         re_error |= !added;
     }
     AWS_ASSERT(re_error == AWS_OP_SUCCESS);
+    (void)re_error;
 }
 
 static void s_sm_connection_on_scheduled_stream_finishes(
@@ -621,7 +785,11 @@ static void s_sm_connection_on_scheduled_stream_finishes(
             aws_random_access_set_remove(&stream_manager->synced_data.ideal_available_set, sm_connection);
             work.sm_connection_to_release = sm_connection;
             --stream_manager->synced_data.holding_connections_count;
-            s_sm_log_stats_synced(stream_manager);
+            /* After we release one connection back, we should check if we need more connections */
+            if (stream_manager->synced_data.state == AWS_H2SMST_READY &&
+                stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_PENDING_ACQUISITION]) {
+                s_check_new_connections_needed_synced(&work);
+            }
         }
         s_unlock_synced_data(stream_manager);
     } /* END CRITICAL SECTION */
@@ -696,9 +864,11 @@ static void s_make_request_task(struct aws_channel_task *task, void *arg, enum a
         .on_complete = s_on_stream_complete,
         .user_data = pending_stream_acquisition,
     };
+    /* TODO: we could put the pending acquisition back to the list if the connection is not available for new request.
+     */
+
     struct aws_http_stream *stream = aws_http_connection_make_request(sm_connection->connection, &request_options);
     if (!stream) {
-        /* TODO: we could put the pending acquisition back to the list instead. */
         error_code = aws_last_error();
         STREAM_MANAGER_LOGF(
             ERROR,
@@ -745,7 +915,6 @@ error:
 static void s_aws_http2_stream_manager_execute_transaction(struct aws_http2_stream_management_transaction *work) {
 
     struct aws_http2_stream_manager *stream_manager = work->stream_manager;
-    STREAM_MANAGER_LOGF(TRACE, stream_manager, "work:%p executes", (void *)work);
 
     /* Step1: Release connection */
     if (work->sm_connection_to_release) {
@@ -755,12 +924,12 @@ static void s_aws_http2_stream_manager_execute_transaction(struct aws_http2_stre
             stream_manager,
             "Release connection:%p back to connection manager as no outstanding streams",
             (void *)work->sm_connection_to_release->connection);
-        s_sm_connection_destroy(work->sm_connection_to_release);
+        s_sm_connection_release_connection(work->sm_connection_to_release);
     }
 
     /* Step2: Make request. The work should know what connection for the request to be made. */
     while (!aws_linked_list_empty(&work->pending_make_requests)) {
-        /* The completions can also fail as the connection can be unavilable after the decision made. We just fail
+        /* The completions can also fail as the connection can be unavailable after the decision made. We just fail
          * the acquisition */
         struct aws_linked_list_node *node = aws_linked_list_pop_front(&work->pending_make_requests);
         struct aws_h2_sm_pending_stream_acquisition *pending_stream_acquisition =
@@ -777,7 +946,6 @@ static void s_aws_http2_stream_manager_execute_transaction(struct aws_http2_stre
             (void *)pending_stream_acquisition,
             (void *)pending_stream_acquisition->sm_connection->connection);
         /**
-         * TODO: Maybe a task per connection instead.
          * schedule a task from the connection's event loop to make request, so that:
          * - We can activate the stream for user and then invoked the callback
          * - The callback will happen asynced even the stream failed to be created
@@ -795,7 +963,7 @@ static void s_aws_http2_stream_manager_execute_transaction(struct aws_http2_stre
 
     /* Step 3: Acquire connections if needed */
     if (work->new_connections) {
-        STREAM_MANAGER_LOGF(TRACE, stream_manager, "acquiring %zu new connections", work->new_connections);
+        STREAM_MANAGER_LOGF(DEBUG, stream_manager, "acquiring %zu new connections", work->new_connections);
     }
     for (size_t i = 0; i < work->new_connections; ++i) {
         aws_http_connection_manager_acquire_connection(
@@ -876,11 +1044,22 @@ void s_stream_manager_on_zero_external_ref(struct aws_http2_stream_manager *stre
 struct aws_http2_stream_manager *aws_http2_stream_manager_new(
     struct aws_allocator *allocator,
     struct aws_http2_stream_manager_options *options) {
-    AWS_PRECONDITION(allocator);
 
+    AWS_PRECONDITION(allocator);
+    /* The other options are validated by the aws_http_connection_manager_new */
+    if (!options->http2_prior_knowledge && !options->tls_connection_options) {
+        AWS_LOGF_ERROR(
+            AWS_LS_HTTP_CONNECTION_MANAGER,
+            "Invalid options - Prior knowledge must be used for cleartext HTTP/2 connections."
+            " Upgrade from HTTP/1.1 is not supported.");
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
     struct aws_http2_stream_manager *stream_manager =
         aws_mem_calloc(allocator, 1, sizeof(struct aws_http2_stream_manager));
     stream_manager->allocator = allocator;
+    aws_linked_list_init(&stream_manager->synced_data.pending_stream_acquisitions);
+
     if (aws_mutex_init(&stream_manager->synced_data.lock)) {
         goto on_error;
     }
@@ -911,18 +1090,32 @@ struct aws_http2_stream_manager *aws_http2_stream_manager_new(
         stream_manager,
         (aws_simple_completion_callback *)s_stream_manager_start_destroy);
 
-    struct aws_http2_setting initial_settings_array[1] = {
-        {
-            .id = AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-            .value = options->initial_window_size,
-        },
-    };
+    if (options->connection_ping_period_ms) {
+        stream_manager->connection_ping_period_ns =
+            aws_timestamp_convert(options->connection_ping_period_ms, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL);
+        size_t connection_ping_timeout_ms =
+            options->connection_ping_timeout_ms ? options->connection_ping_timeout_ms : s_default_ping_timeout_ms;
+        stream_manager->connection_ping_timeout_ns =
+            aws_timestamp_convert(connection_ping_timeout_ms, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL);
+        if (stream_manager->connection_ping_period_ns < stream_manager->connection_ping_timeout_ns) {
+            STREAM_MANAGER_LOGF(
+                WARN,
+                stream_manager,
+                "connection_ping_period_ms: %zu is shorter than connection_ping_timeout_ms: %zu. Clapping "
+                "connection_ping_timeout_ms to %zu",
+                options->connection_ping_period_ms,
+                connection_ping_timeout_ms,
+                options->connection_ping_period_ms);
+            stream_manager->connection_ping_timeout_ns = stream_manager->connection_ping_period_ns;
+        }
+    }
+
     stream_manager->bootstrap = aws_client_bootstrap_acquire(options->bootstrap);
     struct aws_http_connection_manager_options cm_options = {
         .bootstrap = options->bootstrap,
         .socket_options = options->socket_options,
         .tls_connection_options = options->tls_connection_options,
-        .prior_knowledge_http2 = options->tls_connection_options ? false : true,
+        .http2_prior_knowledge = options->http2_prior_knowledge,
         .host = options->host,
         .port = options->port,
         .enable_read_back_pressure = options->enable_read_back_pressure,
@@ -932,8 +1125,10 @@ struct aws_http2_stream_manager *aws_http2_stream_manager_new(
         .max_connections = options->max_connections,
         .shutdown_complete_user_data = stream_manager,
         .shutdown_complete_callback = s_stream_manager_on_cm_shutdown_complete,
-        .initial_settings_array = options->initial_window_size ? initial_settings_array : NULL,
-        .num_initial_settings = options->initial_window_size ? 1 : 0,
+        .initial_settings_array = options->initial_settings_array,
+        .num_initial_settings = options->num_initial_settings,
+        .max_closed_streams = options->max_closed_streams,
+        .http2_conn_manual_window_management = options->conn_manual_window_management,
     };
     /* aws_http_connection_manager_new needs to be the last thing that can fail */
     stream_manager->connection_manager = aws_http_connection_manager_new(allocator, &cm_options);
@@ -950,7 +1145,8 @@ struct aws_http2_stream_manager *aws_http2_stream_manager_new(
     stream_manager->max_concurrent_streams_per_connection =
         options->max_concurrent_streams_per_connection ? options->max_concurrent_streams_per_connection : UINT32_MAX;
     stream_manager->max_connections = options->max_connections;
-    aws_linked_list_init(&stream_manager->synced_data.pending_stream_acquisitions);
+    stream_manager->close_connection_on_server_error = options->close_connection_on_server_error;
+
     return stream_manager;
 on_error:
     s_stream_manager_destroy_final(stream_manager);
@@ -999,3 +1195,34 @@ void aws_http2_stream_manager_acquire_stream(
     } /* END CRITICAL SECTION */
     s_aws_http2_stream_manager_execute_transaction(&work);
 }
+
+static size_t s_get_available_streams_num_from_connection_set(const struct aws_random_access_set *set) {
+    size_t all_available_streams_num = 0;
+    size_t ideal_connection_num = aws_random_access_set_get_size(set);
+    for (size_t i = 0; i < ideal_connection_num; i++) {
+        struct aws_h2_sm_connection *sm_connection = NULL;
+        AWS_FATAL_ASSERT(aws_random_access_set_random_get_ptr_index(set, (void **)&sm_connection, i) == AWS_OP_SUCCESS);
+        uint32_t available_streams = sm_connection->max_concurrent_streams - sm_connection->num_streams_assigned;
+        all_available_streams_num += (size_t)available_streams;
+    }
+    return all_available_streams_num;
+}
+
+void aws_http2_stream_manager_fetch_metrics(
+    const struct aws_http2_stream_manager *stream_manager,
+    struct aws_http_manager_metrics *out_metrics) {
+    AWS_PRECONDITION(stream_manager);
+    AWS_PRECONDITION(out_metrics);
+    { /* BEGIN CRITICAL SECTION */
+        s_lock_synced_data((struct aws_http2_stream_manager *)(void *)stream_manager);
+        size_t all_available_streams_num = 0;
+        all_available_streams_num +=
+            s_get_available_streams_num_from_connection_set(&stream_manager->synced_data.ideal_available_set);
+        all_available_streams_num +=
+            s_get_available_streams_num_from_connection_set(&stream_manager->synced_data.nonideal_available_set);
+        out_metrics->pending_concurrency_acquires =
+            stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_PENDING_ACQUISITION];
+        out_metrics->available_concurrency = all_available_streams_num;
+        s_unlock_synced_data((struct aws_http2_stream_manager *)(void *)stream_manager);
+    } /* END CRITICAL SECTION */
+}

data/aws-crt-ffi/crt/aws-c-http/source/random_access_set.c

@@ -150,7 +150,7 @@ int aws_random_access_set_remove(struct aws_random_access_set *set, const void *
     return AWS_OP_SUCCESS;
 }
 
-int aws_random_access_set_random_get_ptr(struct aws_random_access_set *set, void **out) {
+int aws_random_access_set_random_get_ptr(const struct aws_random_access_set *set, void **out) {
     AWS_PRECONDITION(set);
     AWS_PRECONDITION(out != NULL);
     size_t length = aws_array_list_length(&set->impl->list);
@@ -166,11 +166,11 @@ int aws_random_access_set_random_get_ptr(struct aws_random_access_set *set, void
     return aws_array_list_get_at(&set->impl->list, (void *)out, index);
 }
 
-size_t aws_random_access_set_get_size(struct aws_random_access_set *set) {
+size_t aws_random_access_set_get_size(const struct aws_random_access_set *set) {
     return aws_array_list_length(&set->impl->list);
 }
 
-int aws_random_access_set_exist(struct aws_random_access_set *set, const void *element, bool *exist) {
+int aws_random_access_set_exist(const struct aws_random_access_set *set, const void *element, bool *exist) {
     AWS_PRECONDITION(set);
     AWS_PRECONDITION(element);
     AWS_PRECONDITION(exist);
@@ -179,3 +179,9 @@ int aws_random_access_set_exist(struct aws_random_access_set *set, const void *e
     *exist = find != NULL;
     return re;
 }
+
+int aws_random_access_set_random_get_ptr_index(const struct aws_random_access_set *set, void **out, size_t index) {
+    AWS_PRECONDITION(set);
+    AWS_PRECONDITION(out != NULL);
+    return aws_array_list_get_at(&set->impl->list, (void *)out, index);
+}