aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-event-stream/tests/event_stream_rpc_server_connection_test.c

@@ -116,7 +116,10 @@ static void s_event_loop_shutdown_callback(void *user_data) {
     aws_condition_variable_notify_one(&test_data->shutdown_cvar);
 }
 
-static int s_fixture_setup(struct aws_allocator *allocator, void *ctx) {
+static int s_fixture_setup_shared(
+    struct aws_allocator *allocator,
+    void *ctx,
+    aws_event_stream_rpc_server_on_incoming_stream_fn *on_incoming_stream) {
     aws_event_stream_library_init(allocator);
     struct test_data *test_data = ctx;
     AWS_ZERO_STRUCT(*test_data);
@@ -169,6 +172,94 @@ static int s_fixture_setup(struct aws_allocator *allocator, void *ctx) {
     };
     ASSERT_SUCCESS(testing_channel_init(&test_data->testing_channel, allocator, &testing_channel_options));
 
+    struct aws_event_stream_rpc_connection_options connection_options = {
+        .on_connection_protocol_message = s_fixture_on_protocol_message,
+        .on_incoming_stream = on_incoming_stream,
+        .user_data = test_data,
+    };
+
+    test_data->connection = aws_event_stream_rpc_server_connection_from_existing_channel(
+        test_data->listener, test_data->testing_channel.channel, &connection_options);
+    ASSERT_NOT_NULL(test_data->connection);
+
+    testing_channel_run_currently_queued_tasks(&test_data->testing_channel);
+
+    return AWS_OP_SUCCESS;
+}
+
+static int s_on_server_incoming_stream_failure(
+    struct aws_event_stream_rpc_server_connection *connection,
+    struct aws_event_stream_rpc_server_continuation_token *token,
+    struct aws_byte_cursor operation_name,
+    struct aws_event_stream_rpc_server_stream_continuation_options *continuation_options,
+    void *user_data) {
+
+    (void)connection;
+    (void)token;
+    (void)operation_name;
+    (void)continuation_options;
+    (void)user_data;
+
+    return AWS_OP_ERR;
+}
+
+static int s_fixture_setup_new_stream_failure(struct aws_allocator *allocator, void *ctx) {
+    return s_fixture_setup_shared(allocator, ctx, s_on_server_incoming_stream_failure);
+}
+
+static int s_fixture_setup(struct aws_allocator *allocator, void *ctx) {
+    return s_fixture_setup_shared(allocator, ctx, s_on_server_incoming_stream_shim);
+}
+
+static int s_fixture_setup_port0(struct aws_allocator *allocator, void *ctx) {
+    aws_event_stream_library_init(allocator);
+    struct test_data *test_data = ctx;
+    AWS_ZERO_STRUCT(*test_data);
+
+    struct aws_shutdown_callback_options el_shutdown_options = {
+        .shutdown_callback_fn = s_event_loop_shutdown_callback,
+        .shutdown_callback_user_data = test_data,
+    };
+    test_data->el_group = aws_event_loop_group_new_default(allocator, 0, &el_shutdown_options);
+    ASSERT_NOT_NULL(test_data->el_group);
+    test_data->server_bootstrap = aws_server_bootstrap_new(allocator, test_data->el_group);
+    ASSERT_NOT_NULL(test_data->server_bootstrap);
+
+    ASSERT_SUCCESS(aws_mutex_init(&test_data->shutdown_lock));
+    ASSERT_SUCCESS(aws_condition_variable_init(&test_data->shutdown_cvar));
+
+    struct aws_socket_options socket_options = {
+        .connect_timeout_ms = 3000,
+        .domain = AWS_SOCKET_IPV4,
+        .type = AWS_SOCKET_STREAM,
+    };
+
+    /* Find a random open port directly by ask bind() with port 0 */
+    uint16_t test_port = 0;
+    struct aws_event_stream_rpc_server_listener_options listener_options = {
+        .socket_options = &socket_options,
+        .host_name = "127.0.0.1",
+        .port = test_port,
+        .bootstrap = test_data->server_bootstrap,
+        .user_data = test_data,
+        .on_new_connection = s_fixture_on_new_server_connection,
+        .on_connection_shutdown = s_fixture_on_server_connection_shutdown,
+        .on_destroy_callback = s_on_listener_destroy,
+    };
+
+    test_data->listener = aws_event_stream_rpc_server_new_listener(allocator, &listener_options);
+    ASSERT_NOT_NULL(test_data->listener);
+
+    uint16_t actual_port = aws_event_stream_rpc_server_listener_get_bound_port(test_data->listener);
+    ASSERT_TRUE(actual_port > 0);
+
+    test_data->allocator = allocator;
+
+    struct aws_testing_channel_options testing_channel_options = {
+        .clock_fn = aws_high_res_clock_get_ticks,
+    };
+    ASSERT_SUCCESS(testing_channel_init(&test_data->testing_channel, allocator, &testing_channel_options));
+
     struct aws_event_stream_rpc_connection_options connection_options = {
         .on_connection_protocol_message = s_fixture_on_protocol_message,
         .on_incoming_stream = s_on_server_incoming_stream_shim,
@@ -208,6 +299,7 @@ static int s_fixture_shutdown(struct aws_allocator *allocator, int setup_result,
         aws_condition_variable_wait_pred(
             &test_data->shutdown_cvar, &test_data->shutdown_lock, s_shutdown_predicate_fn, test_data);
         aws_mutex_unlock(&test_data->shutdown_lock);
+        aws_thread_join_all_managed();
         aws_mutex_clean_up(&test_data->shutdown_lock);
         aws_condition_variable_clean_up(&test_data->shutdown_cvar);
     }
@@ -233,6 +325,13 @@ AWS_TEST_CASE_FIXTURE(
     s_fixture_shutdown,
     &s_test_data)
 
+AWS_TEST_CASE_FIXTURE(
+    test_event_stream_rpc_server_connection_setup_and_teardown_with_bind_to_zero_port,
+    s_fixture_setup_port0,
+    s_test_event_stream_rpc_server_connection_setup_and_teardown,
+    s_fixture_shutdown,
+    &s_test_data)
+
 struct received_protocol_message_data {
     struct aws_allocator *allocator;
     enum aws_event_stream_rpc_message_type message_type;
@@ -1214,6 +1313,74 @@ AWS_TEST_CASE_FIXTURE(
     s_fixture_shutdown,
     &s_test_data)
 
+static int s_test_event_stream_rpc_server_connection_continuation_failure(struct aws_allocator *allocator, void *ctx) {
+    struct test_data *test_data = ctx;
+
+    struct received_protocol_message_data message_data = {
+        .allocator = allocator,
+    };
+
+    test_data->user_data = &message_data;
+    test_data->received_fn = s_on_recieved_protocol_message;
+    test_data->continuation_user_data = &message_data;
+    test_data->on_continuation = s_on_continuation_message;
+    test_data->on_continuation_closed = s_on_continuation_closed;
+
+    s_do_connect(allocator, test_data, &message_data);
+
+    struct aws_byte_buf payload = aws_byte_buf_from_c_str("test operation payload!");
+    struct aws_event_stream_message message;
+    struct aws_array_list headers_list;
+    ASSERT_SUCCESS(aws_event_stream_headers_list_init(&headers_list, allocator));
+
+    struct aws_byte_cursor operation_name = aws_byte_cursor_from_c_str("testOperation");
+    ASSERT_SUCCESS(aws_event_stream_add_int32_header(
+        &headers_list,
+        (const char *)aws_event_stream_rpc_message_type_name.ptr,
+        (uint8_t)aws_event_stream_rpc_message_type_name.len,
+        AWS_EVENT_STREAM_RPC_MESSAGE_TYPE_APPLICATION_MESSAGE));
+    ASSERT_SUCCESS(aws_event_stream_add_int32_header(
+        &headers_list,
+        (const char *)aws_event_stream_rpc_message_flags_name.ptr,
+        (uint8_t)aws_event_stream_rpc_message_flags_name.len,
+        0));
+    ASSERT_SUCCESS(aws_event_stream_add_int32_header(
+        &headers_list,
+        (const char *)aws_event_stream_rpc_stream_id_name.ptr,
+        (uint8_t)aws_event_stream_rpc_stream_id_name.len,
+        1));
+    ASSERT_SUCCESS(aws_event_stream_add_string_header(
+        &headers_list,
+        (const char *)aws_event_stream_rpc_operation_name.ptr,
+        (uint8_t)aws_event_stream_rpc_operation_name.len,
+        (const char *)operation_name.ptr,
+        (uint16_t)operation_name.len,
+        0));
+
+    ASSERT_SUCCESS(aws_event_stream_message_init(&message, allocator, &headers_list, &payload));
+
+    struct aws_byte_cursor send_data = aws_byte_cursor_from_array(
+        aws_event_stream_message_buffer(&message), aws_event_stream_message_total_length(&message));
+    ASSERT_SUCCESS(testing_channel_push_read_data(&test_data->testing_channel, send_data));
+    testing_channel_drain_queued_tasks(&test_data->testing_channel);
+    aws_event_stream_message_clean_up(&message);
+    aws_array_list_clean_up(&headers_list);
+
+    ASSERT_NULL(message_data.continuation_token);
+
+    aws_event_stream_rpc_server_connection_close(test_data->connection, AWS_ERROR_SUCCESS);
+    testing_channel_drain_queued_tasks(&test_data->testing_channel);
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE_FIXTURE(
+    test_event_stream_rpc_server_connection_continuation_failure,
+    s_fixture_setup_new_stream_failure,
+    s_test_event_stream_rpc_server_connection_continuation_failure,
+    s_fixture_shutdown,
+    &s_test_data)
+
 static int s_test_event_stream_rpc_server_connection_continuation_missing_operation(
     struct aws_allocator *allocator,
     void *ctx) {

data/aws-crt-ffi/crt/aws-c-event-stream/tests/message_deserializer_test.c

@@ -15,7 +15,8 @@ static int s_test_outgoing_no_op_valid_fn(struct aws_allocator *allocator, void
     struct aws_event_stream_message message;
     struct aws_byte_buf test_buf = aws_byte_buf_from_array(test_data, sizeof(test_data));
     ASSERT_SUCCESS(
-        aws_event_stream_message_from_buffer(&message, NULL, &test_buf), "Message validation should have succeeded");
+        aws_event_stream_message_from_buffer(&message, allocator, &test_buf),
+        "Message validation should have succeeded");
 
     ASSERT_INT_EQUALS(
         0x00000010, aws_event_stream_message_total_length(&message), "Message length should have been 0x10");
@@ -43,7 +44,8 @@ static int s_test_outgoing_application_data_no_headers_valid_fn(struct aws_alloc
     struct aws_byte_buf test_buf = aws_byte_buf_from_array(test_data, sizeof(test_data));
 
     ASSERT_SUCCESS(
-        aws_event_stream_message_from_buffer(&message, NULL, &test_buf), "Message validation should have succeeded");
+        aws_event_stream_message_from_buffer(&message, allocator, &test_buf),
+        "Message validation should have succeeded");
 
     ASSERT_INT_EQUALS(
         0x0000001D, aws_event_stream_message_total_length(&message), "Message length should have been 0x0000001D");

data/aws-crt-ffi/crt/aws-c-http/CMakeLists.txt

@@ -6,6 +6,7 @@ if (POLICY CMP0069)
 endif()
 
 option(ENABLE_PROXY_INTEGRATION_TESTS "Whether to run the proxy integration tests that rely on pre-configured proxy" OFF)
+option(ENABLE_LOCALHOST_INTEGRATION_TESTS "Whether to run the integration tests that rely on pre-configured localhost" OFF)
 
 if (DEFINED CMAKE_PREFIX_PATH)
     file(TO_CMAKE_PATH "${CMAKE_PREFIX_PATH}" CMAKE_PREFIX_PATH)

data/aws-crt-ffi/crt/aws-c-http/README.md

@@ -51,3 +51,11 @@ git clone git@github.com:awslabs/aws-c-http.git
 cmake -S aws-c-http -B aws-c-http/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
 cmake --build aws-c-http/build --target install
 ```
+
+#### Run Integration Tests with localhost
+
+To run some of the integration tests (start with localhost_integ_*), you need to set up a localhost that echo the request headers from `/echo` back first.
+
+To do that, check [localhost](./tests/py_localhost/) script we have.
+
+After that, configure and build your cmake project with `-DENABLE_LOCALHOST_INTEGRATION_TESTS=true` to build the tests with localhost and run them from `ctest --output-on-failure -R localhost_integ_*`.

data/aws-crt-ffi/crt/aws-c-http/bin/elasticurl/main.c

@@ -763,7 +763,7 @@ int main(int argc, char **argv) {
     }
 
     if (app_ctx.input_body) {
-        aws_input_stream_destroy(app_ctx.input_body);
+        aws_input_stream_release(app_ctx.input_body);
     }
 
     if (app_ctx.input_file) {

data/aws-crt-ffi/crt/aws-c-http/builder.json

@@ -11,10 +11,11 @@
         { "name": "aws-c-compression" }
     ],
     "downstream": [
-        { "name": "aws-c-auth" }
+        { "name": "aws-c-auth" },
+        { "name": "aws-c-mqtt" }
     ],
     "test_steps": [
-        ["bash", "./.builder/action/aws-c-http-test.sh"],
-        ["{python}", "./integration-testing/http_client_test.py", "{install_dir}/bin/elasticurl{exe}"]
+        "aws-c-http-test",
+        ["{python}", "{source_dir}/integration-testing/http_client_test.py", "{install_dir}/bin/elasticurl{exe}"]
     ]
 }

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/connection.h

@@ -463,6 +463,13 @@ void aws_http_connection_release(struct aws_http_connection *connection);
 AWS_HTTP_API
 void aws_http_connection_close(struct aws_http_connection *connection);
 
+/**
+ * Stop accepting new requests for the connection. It will NOT start the shutdown process for the connection. The
+ * requests that are already open can still wait to be completed, but new requests will fail to be created,
+ */
+AWS_HTTP_API
+void aws_http_connection_stop_new_requests(struct aws_http_connection *connection);
+
 /**
  * Returns true unless the connection is closed or closing.
  */
@@ -597,7 +604,7 @@ void aws_http2_connection_get_remote_settings(
  */
 
 AWS_HTTP_API
-int aws_http2_connection_send_goaway(
+void aws_http2_connection_send_goaway(
     struct aws_http_connection *http2_connection,
     uint32_t http2_error,
     bool allow_more_streams,

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/connection_manager.h

@@ -25,6 +25,23 @@ typedef void(aws_http_connection_manager_on_connection_setup_fn)(
 
 typedef void(aws_http_connection_manager_shutdown_complete_fn)(void *user_data);
 
+/**
+ * Metrics for logging and debugging purpose.
+ */
+struct aws_http_manager_metrics {
+    /**
+     * The number of additional concurrent requests that can be supported by the HTTP manager without needing to
+     * establish additional connections to the target server.
+     *
+     * For connection manager, it equals to connections that's idle.
+     * For stream manager, it equals to the number of streams that are possible to be made without creating new
+     * connection, although the implementation can create new connection without fully filling it.
+     */
+    size_t available_concurrency;
+    /* The number of requests that are awaiting concurrency to be made available from the HTTP manager. */
+    size_t pending_concurrency_acquires;
+};
+
 /*
  * Connection manager configuration struct.
  *
@@ -38,11 +55,28 @@ struct aws_http_connection_manager_options {
     struct aws_client_bootstrap *bootstrap;
     size_t initial_window_size;
     const struct aws_socket_options *socket_options;
+
+    /**
+     * Options to create secure (HTTPS) connections.
+     * For secure connections, set "h2" in the ALPN string for HTTP/2, otherwise HTTP/1.1 is used.
+     *
+     * Leave NULL to create cleartext (HTTP) connections.
+     * For cleartext connections, use `http2_prior_knowledge` (RFC-7540 3.4)
+     * to control whether that are treated as HTTP/1.1 or HTTP/2.
+     */
     const struct aws_tls_connection_options *tls_connection_options;
+
+    /**
+     * Specify whether you have prior knowledge that cleartext (HTTP) connections are HTTP/2 (RFC-7540 3.4).
+     * If false, then cleartext connections are treated as HTTP/1.1.
+     * It is illegal to set this true when secure connections are being used.
+     * Note that upgrading from HTTP/1.1 to HTTP/2 is not supported (RFC-7540 3.2).
+     */
+    bool http2_prior_knowledge;
+
     const struct aws_http_connection_monitoring_options *monitoring_options;
     struct aws_byte_cursor host;
     uint16_t port;
-    bool prior_knowledge_http2;
 
     /**
      * Optional.
@@ -137,12 +171,22 @@ void aws_http_connection_manager_acquire_connection(
 /*
  * Returns a connection back to the manager.  All acquired connections must
  * eventually be released back to the manager in order to avoid a resource leak.
+ *
+ * Note: it can lead to another acquired callback to be invoked within the thread.
  */
 AWS_HTTP_API
 int aws_http_connection_manager_release_connection(
     struct aws_http_connection_manager *manager,
     struct aws_http_connection *connection);
 
+/**
+ * Fetch the current manager metrics from connection manager.
+ */
+AWS_HTTP_API
+void aws_http_connection_manager_fetch_metrics(
+    const struct aws_http_connection_manager *manager,
+    struct aws_http_manager_metrics *out_metrics);
+
 AWS_EXTERN_C_END
 
 #endif /* AWS_HTTP_CONNECTION_MANAGER_H */

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/http2_stream_manager.h

@@ -18,6 +18,7 @@ struct proxy_env_var_settings;
 struct aws_http2_setting;
 struct aws_http_make_request_options;
 struct aws_http_stream;
+struct aws_http_manager_metrics;
 
 /**
  * Always invoked asynchronously when the stream was created, successfully or not.
@@ -47,29 +48,48 @@ struct aws_http2_stream_manager_options {
      */
     struct aws_client_bootstrap *bootstrap;
     const struct aws_socket_options *socket_options;
+
     /**
-     * If TLS options is set, you also need to handle ALPN, otherwise, may not able to get HTTP/2 connection and fail
-     * the stream manager.
-     * If TLS options not set, prior knowledge will be used.
+     * Options to create secure (HTTPS) connections.
+     * For secure connections, the ALPN string must be "h2".
+     *
+     * To create cleartext (HTTP) connections, leave this NULL
+     * and set `http2_prior_knowledge` (RFC-7540 3.4).
      */
     const struct aws_tls_connection_options *tls_connection_options;
+
+    /**
+     * Specify whether you have prior knowledge that cleartext (HTTP) connections are HTTP/2 (RFC-7540 3.4).
+     * It is illegal to set this true when secure connections are being used.
+     * Note that upgrading from HTTP/1.1 to HTTP/2 is not supported (RFC-7540 3.2).
+     */
+    bool http2_prior_knowledge;
+
     struct aws_byte_cursor host;
     uint16_t port;
 
+    /**
+     * Optional.
+     * HTTP/2 connection configuration. Check `struct aws_http2_connection_options` for details of each config.
+     * Notes for window control:
+     * - By default, client will will maintain its flow-control windows such that no back-pressure is applied and data
+     * arrives as fast as possible.
+     * - For connection level window control, `conn_manual_window_management` will enable manual control. The
+     * inital window size is not controllable.
+     * - For stream level window control, `enable_read_back_pressure` will enable manual control. The initial window
+     * size needs to be set through `initial_settings_array`.
+     */
+    struct aws_http2_setting *initial_settings_array;
+    size_t num_initial_settings;
+    size_t max_closed_streams;
+    bool conn_manual_window_management;
+
     /**
      * HTTP/2 Stream window control.
      * If set to true, the read back pressure mechanism will be enabled for streams created.
-     * The initial window size can be set through `initial window size`
+     * The initial window size can be set by `AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE` via `initial_settings_array`
      */
     bool enable_read_back_pressure;
-    /**
-     * Optional.
-     * If set, it will be sent to the peer as the `AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE` in the initial settings for
-     * HTTP/2 connection.
-     * If not set, the default will be used, which is 65,535 (2^16-1)(RFC-7540 6.5.2)
-     * Ignored if enable_read_back_pressure is false.
-     */
-    uint32_t initial_window_size;
 
     /* Connection monitor for the underlying connections made */
     const struct aws_http_connection_monitoring_options *monitoring_options;
@@ -85,6 +105,26 @@ struct aws_http2_stream_manager_options {
     void *shutdown_complete_user_data;
     aws_http2_stream_manager_shutdown_complete_fn *shutdown_complete_callback;
 
+    /**
+     * Optional.
+     * When set, connection will be closed if 5xx response received from server.
+     */
+    bool close_connection_on_server_error;
+    /**
+     * Optional.
+     * The period for all the connections held by stream manager to send a PING in milliseconds.
+     * If you specify 0, manager will NOT send any PING.
+     * Note: if set, it must be large than the time of ping timeout setting.
+     */
+    size_t connection_ping_period_ms;
+    /**
+     * Optional.
+     * Network connection will be closed if a ping response is not received
+     * within this amount of time (milliseconds).
+     * If you specify 0, a default value will be used.
+     */
+    size_t connection_ping_timeout_ms;
+
     /* TODO: More flexible policy about the connections, but will always has these three values below. */
     /**
      * Optional.
@@ -160,5 +200,16 @@ void aws_http2_stream_manager_acquire_stream(
     struct aws_http2_stream_manager *http2_stream_manager,
     const struct aws_http2_stream_manager_acquire_stream_options *acquire_stream_option);
 
+/**
+ * Fetch the current metrics from stream manager.
+ *
+ * @param http2_stream_manager
+ * @param out_metrics The metrics to be fetched
+ */
+AWS_HTTP_API
+void aws_http2_stream_manager_fetch_metrics(
+    const struct aws_http2_stream_manager *http2_stream_manager,
+    struct aws_http_manager_metrics *out_metrics);
+
 AWS_EXTERN_C_END
 #endif /* AWS_HTTP2_STREAM_MANAGER_H */

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/connection_impl.h

@@ -40,6 +40,7 @@ struct aws_http_connection_vtable {
         const struct aws_http_request_handler_options *options);
     int (*stream_send_response)(struct aws_http_stream *stream, struct aws_http_message *response);
     void (*close)(struct aws_http_connection *connection);
+    void (*stop_new_requests)(struct aws_http_connection *connection);
     bool (*is_open)(const struct aws_http_connection *connection);
     bool (*new_requests_allowed)(const struct aws_http_connection *connection);
 
@@ -56,7 +57,7 @@ struct aws_http_connection_vtable {
         const struct aws_byte_cursor *optional_opaque_data,
         aws_http2_on_ping_complete_fn *on_completed,
         void *user_data);
-    int (*send_goaway)(
+    void (*send_goaway)(
         struct aws_http_connection *http2_connection,
         uint32_t http2_error,
         bool allow_more_streams,

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/h2_connection.h

@@ -13,6 +13,7 @@
 
 #include <aws/http/private/connection_impl.h>
 #include <aws/http/private/h2_frames.h>
+#include <aws/http/statistics.h>
 
 struct aws_h2_decoder;
 struct aws_h2_stream;
@@ -70,6 +71,14 @@ struct aws_h2_connection {
          * Waiting for WINDOW_UPDATE to set them free */
         struct aws_linked_list stalled_window_streams_list;
 
+        /* List using aws_h2_stream.node.
+         * Contains all streams that are open, but are only sending data when notified, rather than polling
+         * for it (e.g. event streams)
+         * Streams are moved to the outgoing_streams_list until they send pending data, then are moved back
+         * to this list to sleep until more data comes in
+         */
+        struct aws_linked_list waiting_streams_list;
+
         /* List using aws_h2_frame.node.
          * Queues all frames (except DATA frames) for connection to send.
          * When queue is empty, then we send DATA frames from the outgoing_streams_list */
@@ -108,6 +117,14 @@ struct aws_h2_connection {
         int channel_shutdown_error_code;
         bool channel_shutdown_immediately;
         bool channel_shutdown_waiting_for_goaway_to_be_written;
+
+        /* TODO: Consider adding stream monitor */
+        struct aws_crt_statistics_http2_channel stats;
+
+        /* Timestamp when connection has data to send, which is when there is an active stream with body to send */
+        uint64_t outgoing_timestamp_ns;
+        /* Timestamp when connection has data to receive, which is when there is an active stream */
+        uint64_t incoming_timestamp_ns;
     } thread_data;
 
     /* Any thread may touch this data, but the lock must be held (unless it's an atomic) */
@@ -200,8 +217,9 @@ enum aws_h2_stream_closed_when {
 enum aws_h2_data_encode_status {
     AWS_H2_DATA_ENCODE_COMPLETE,
     AWS_H2_DATA_ENCODE_ONGOING,
-    AWS_H2_DATA_ENCODE_ONGOING_BODY_STALLED,
-    AWS_H2_DATA_ENCODE_ONGOING_WINDOW_STALLED,
+    AWS_H2_DATA_ENCODE_ONGOING_BODY_STREAM_STALLED, /* stalled reading from body stream */
+    AWS_H2_DATA_ENCODE_ONGOING_WAITING_FOR_WRITES,  /* waiting for next manual write */
+    AWS_H2_DATA_ENCODE_ONGOING_WINDOW_STALLED,      /* stalled due to reduced window size */
 };
 
 /* When window size is too small to fit the possible padding into it, we stop sending data and wait for WINDOW_UPDATE */

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/h2_frames.h

@@ -55,6 +55,7 @@ struct aws_h2err {
 #define AWS_H2_WINDOW_UPDATE_MAX (0x7FFFFFFF) /* cannot use high bit */
 #define AWS_H2_STREAM_ID_MAX (0x7FFFFFFF)     /* cannot use high bit */
 #define AWS_H2_FRAME_PREFIX_SIZE (9)
+#define AWS_H2_INIT_WINDOW_SIZE (65535) /* Defined initial window size */
 
 /* Legal min(inclusive) and max(inclusive) for each setting */
 extern const uint32_t aws_h2_settings_bounds[AWS_HTTP2_SETTINGS_END_RANGE][2];

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/h2_stream.h

@@ -53,6 +53,23 @@ enum aws_h2_stream_api_state {
     AWS_H2_STREAM_API_STATE_COMPLETE,
 };
 
+/* Indicates the state of the body of the HTTP/2 stream */
+enum aws_h2_stream_body_state {
+    AWS_H2_STREAM_BODY_STATE_NONE,           /* Has no body for the HTTP/2 stream */
+    AWS_H2_STREAM_BODY_STATE_WAITING_WRITES, /* Has no active body, but waiting for more to be
+                                                write */
+    AWS_H2_STREAM_BODY_STATE_ONGOING,        /* Has active ongoing body */
+};
+
+/* represents a write operation, which will be turned into a data frame */
+struct aws_h2_stream_data_write {
+    struct aws_linked_list_node node;
+    struct aws_input_stream *data_stream;
+    aws_http2_stream_write_data_complete_fn *on_complete;
+    void *user_data;
+    bool end_stream;
+};
+
 struct aws_h2_stream {
     struct aws_http_stream base;
 
@@ -68,7 +85,21 @@ struct aws_h2_stream {
          * We leave it up to the remote peer to detect whether the max window size has been exceeded. */
         int64_t window_size_self;
         struct aws_http_message *outgoing_message;
+        /* All queued writes. If the message provides a body stream, it will be first in this list
+         * This list can drain, which results in the stream being put to sleep (moved to waiting_streams_list in
+         * h2_connection). */
+        struct aws_linked_list outgoing_writes; /* aws_http2_stream_data_write */
         bool received_main_headers;
+
+        bool content_length_received;
+        /* Set if incoming message has content-length header */
+        uint64_t incoming_content_length;
+        /* The total length of payload of data frame received */
+        uint64_t incoming_data_length;
+        /* Indicates that the stream is currently in the waiting_streams_list and is
+         * asleep. When stream needs to be awaken, moving the stream back to the outgoing_streams_list and set this bool
+         * to false */
+        bool waiting_for_writes;
     } thread_data;
 
     /* Any thread may touch this data, but the lock must be held (unless it's an atomic) */
@@ -84,22 +115,21 @@ struct aws_h2_stream {
          * code we want to inform user about. */
         struct aws_h2err reset_error;
         bool reset_called;
+        bool manual_write_ended;
 
         /* Simplified stream state. */
         enum aws_h2_stream_api_state api_state;
+
+        /* any data streams sent manually via aws_http2_stream_write_data */
+        struct aws_linked_list pending_write_list; /* aws_h2_stream_pending_data */
     } synced_data;
+    bool manual_write;
 
     /* Store the sent reset HTTP/2 error code, set to -1, if none has sent so far */
     int64_t sent_reset_error_code;
 
     /* Store the received reset HTTP/2 error code, set to -1, if none has received so far */
     int64_t received_reset_error_code;
-
-    /**
-     * Back up the message if we create a new message from it to keep the underlying input stream alive.
-     * TODO: remove this once we have input stream refcounted
-     */
-    struct aws_http_message *backup_outgoing_message;
 };
 
 const char *aws_h2_stream_state_to_str(enum aws_h2_stream_state state);
@@ -113,16 +143,15 @@ enum aws_h2_stream_state aws_h2_stream_get_state(const struct aws_h2_stream *str
 struct aws_h2err aws_h2_stream_window_size_change(struct aws_h2_stream *stream, int32_t size_changed, bool self);
 
 /* Connection is ready to send frames from stream now */
-int aws_h2_stream_on_activated(struct aws_h2_stream *stream, bool *out_has_outgoing_data);
+int aws_h2_stream_on_activated(struct aws_h2_stream *stream, enum aws_h2_stream_body_state *body_state);
+
+/* Completes stream for one reason or another, clean up any pending writes/resources. */
+void aws_h2_stream_complete(struct aws_h2_stream *stream, int error_code);
 
 /* Connection is ready to send data from stream now.
  * Stream may complete itself during this call.
- * data_encode_status:
- * AWS_H2_DATA_ENCODE_COMPLETE: Finished encoding data for the stream
- * AWS_H2_DATA_ENCODE_ONGOING: Stream has more data to send.
- * AWS_H2_DATA_ENCODE_ONGOING_BODY_STALLED: Stream has more data to send, but it's not ready right now
- * AWS_H2_DATA_ENCODE_ONGOING_WINDOW_STALLED: Stream has more data to send but its window size is too small, and stream
- * will be moved to stalled_window_stream_list */
+ * data_encode_status: see `aws_h2_data_encode_status`
+ */
 int aws_h2_stream_encode_data_frame(
     struct aws_h2_stream *stream,
     struct aws_h2_frame_encoder *encoder,