aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-http/tests/py_localhost/server.py

@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+# Minor change based on the example from hyper h2 server
+# https://github.com/python-hyper/h2/blob/master/examples/asyncio/asyncio-server.py
+
+"""
+asyncio-server.py
+~~~~~~~~~~~~~~~~~
+
+A fully-functional HTTP/2 server using asyncio. Requires Python 3.5+.
+
+This example demonstrates handling requests with bodies, as well as handling
+those without. In particular, it demonstrates the fact that DataReceived may
+be called multiple times, and that applications must handle that possibility.
+"""
+import asyncio
+import io
+import json
+import ssl
+import time
+import os
+import collections
+from typing import List, Tuple
+
+from h2.config import H2Configuration
+from h2.connection import H2Connection
+from h2.events import (
+    ConnectionTerminated, DataReceived, RemoteSettingsChanged,
+    RequestReceived, StreamEnded, StreamReset, WindowUpdated
+)
+from h2.errors import ErrorCodes
+from h2.exceptions import ProtocolError, StreamClosedError
+from h2.settings import SettingCodes
+
+
+RequestData = collections.namedtuple('RequestData', ['headers', 'data'])
+
+
+class H2Protocol(asyncio.Protocol):
+    def __init__(self):
+        config = H2Configuration(client_side=False, header_encoding='utf-8')
+        self.conn = H2Connection(config=config)
+        self.transport = None
+        self.stream_data = {}
+        self.flow_control_futures = {}
+        self.file_path = None
+        self.num_sentence_received = {}
+        self.raw_headers = None
+        self.download_test_length = 2500000000
+        self.out_bytes_per_second = 900
+
+    def connection_made(self, transport: asyncio.Transport):
+        self.transport = transport
+        self.conn.initiate_connection()
+        self.transport.write(self.conn.data_to_send())
+
+    def connection_lost(self, exc):
+        for future in self.flow_control_futures.values():
+            future.cancel()
+        self.flow_control_futures = {}
+
+    def data_received(self, data: bytes):
+        try:
+            events = self.conn.receive_data(data)
+        except ProtocolError as e:
+            self.transport.write(self.conn.data_to_send())
+            self.transport.close()
+        else:
+            self.transport.write(self.conn.data_to_send())
+            for event in events:
+                if isinstance(event, RequestReceived):
+                    self.request_received(event.headers, event.stream_id)
+                elif isinstance(event, DataReceived):
+                    self.receive_data(event.data, event.stream_id)
+                elif isinstance(event, StreamEnded):
+                    self.stream_complete(event.stream_id)
+                elif isinstance(event, ConnectionTerminated):
+                    self.transport.close()
+                elif isinstance(event, StreamReset):
+                    self.stream_reset(event.stream_id)
+                elif isinstance(event, WindowUpdated):
+                    self.window_updated(event.stream_id, event.delta)
+                elif isinstance(event, RemoteSettingsChanged):
+                    if SettingCodes.INITIAL_WINDOW_SIZE in event.changed_settings:
+                        self.window_updated(None, 0)
+
+                self.transport.write(self.conn.data_to_send())
+
+    def request_received(self, headers: List[Tuple[str, str]], stream_id: int):
+        self.raw_headers = headers
+        headers = collections.OrderedDict(headers)
+        path = headers[':path']
+        method = headers[':method']
+        if method == "PUT" or method == "POST":
+            self.file_path = os.path.join(os.path.curdir, path[1:])
+            if os.path.exists(self.file_path):
+                os.remove(self.file_path)
+
+        # Store off the request data.
+        request_data = RequestData(headers, io.BytesIO())
+        self.stream_data[stream_id] = request_data
+
+    def handle_request_echo(self, stream_id: int, request_data: RequestData):
+        response_headers = [(':status', '200')]
+        for i in self.raw_headers:
+            # Response headers back and exclude pseudo headers
+            if i[0][0] != ':':
+                response_headers.append(i)
+        body = request_data.data.getvalue().decode('utf-8')
+        data = json.dumps(
+            {"body": body}, indent=4
+        ).encode("utf8")
+        self.conn.send_headers(stream_id, response_headers)
+        asyncio.ensure_future(self.send_data(data, stream_id))
+
+    def stream_complete(self, stream_id: int):
+        """
+        When a stream is complete, we can send our response.
+        """
+        try:
+            request_data = self.stream_data[stream_id]
+        except KeyError:
+            # Just return, we probably 405'd this already
+            return
+
+        path = request_data.headers[':path']
+        method = request_data.headers[':method']
+        if method == "PUT" or method == "POST":
+            self.conn.send_headers(stream_id, [(':status', '200')])
+            asyncio.ensure_future(self.send_data(
+                str(self.num_sentence_received[stream_id]).encode(), stream_id))
+        elif path == '/echo':
+            self.handle_request_echo(stream_id, request_data)
+        elif path == '/downloadTest':
+            length = self.download_test_length
+            self.conn.send_headers(
+                stream_id, [(':status', '200'), ('content-length', str(length))])
+            asyncio.ensure_future(self.send_repeat_data(length, stream_id))
+        elif path == '/slowConnTest':
+            length = int(self.download_test_length/1000)
+            self.conn.send_headers(
+                stream_id, [(':status', '200'), ('content-length', str(length))])
+            asyncio.ensure_future(
+                self.send_slow_repeat_data(length, stream_id))
+        else:
+            self.conn.send_headers(stream_id, [(':status', '404')])
+            asyncio.ensure_future(self.send_data(b"Not Found", stream_id))
+
+    def receive_data(self, data: bytes, stream_id: int):
+        """
+        We've received some data on a stream. If that stream is one we're
+        expecting data on, save it off. Otherwise, reset the stream.
+        """
+        try:
+            stream_data = self.stream_data[stream_id]
+        except KeyError:
+            self.conn.reset_stream(
+                stream_id, error_code=ErrorCodes.PROTOCOL_ERROR
+            )
+        else:
+            method = stream_data.headers[':method']
+            if method == "PUT" or method == "POST":
+                if stream_id in self.num_sentence_received:
+                    self.num_sentence_received[stream_id] = self.num_sentence_received[stream_id] + \
+                        len(data)
+                else:
+                    self.num_sentence_received[stream_id] = len(data)
+                # update window for stream
+                if len(data) > 0:
+                    self.conn.increment_flow_control_window(len(data))
+                    self.conn.increment_flow_control_window(
+                        len(data), stream_id)
+            else:
+                stream_data.data.write(data)
+
+    def stream_reset(self, stream_id):
+        """
+        A stream reset was sent. Stop sending data.
+        """
+        if stream_id in self.flow_control_futures:
+            future = self.flow_control_futures.pop(stream_id)
+            future.cancel()
+
+    async def send_data(self, data, stream_id):
+        """
+        Send data according to the flow control rules.
+        """
+        while data:
+            while self.conn.local_flow_control_window(stream_id) < 1:
+                try:
+                    await self.wait_for_flow_control(stream_id)
+                except asyncio.CancelledError:
+                    return
+
+            chunk_size = min(
+                self.conn.local_flow_control_window(stream_id),
+                len(data),
+                self.conn.max_outbound_frame_size,
+            )
+
+            try:
+                self.conn.send_data(
+                    stream_id,
+                    data[:chunk_size],
+                    end_stream=(chunk_size == len(data))
+                )
+            except (StreamClosedError, ProtocolError):
+                # The stream got closed and we didn't get told. We're done
+                # here.
+                break
+
+            self.transport.write(self.conn.data_to_send())
+            data = data[chunk_size:]
+
+    async def send_repeat_data(self, length, stream_id):
+        """
+        Send data with length according to the flow control rules.
+        """
+        while length > 0:
+            while self.conn.local_flow_control_window(stream_id) < 1:
+                try:
+                    await self.wait_for_flow_control(stream_id)
+                except asyncio.CancelledError:
+                    return
+
+            chunk_size = min(
+                self.conn.local_flow_control_window(stream_id),
+                length,
+                self.conn.max_outbound_frame_size,
+            )
+            repeated = b"This is CRT HTTP test."
+            data = int(chunk_size/len(repeated)) * repeated + \
+                repeated[:chunk_size % len(repeated)]
+
+            try:
+                self.conn.send_data(
+                    stream_id,
+                    data,
+                    end_stream=(chunk_size == length)
+                )
+            except (StreamClosedError, ProtocolError):
+                # The stream got closed and we didn't get told. We're done
+                # here.
+                break
+
+            self.transport.write(self.conn.data_to_send())
+            length = length - chunk_size
+
+    async def send_slow_repeat_data(self, length, stream_id):
+        """
+        Send data with length slowly (less than 1000 bytes per second)
+        """
+        while length > 0:
+            while self.conn.local_flow_control_window(stream_id) < 1:
+                try:
+                    await self.wait_for_flow_control(stream_id)
+                except asyncio.CancelledError:
+                    return
+
+            chunk_size = min(
+                self.conn.local_flow_control_window(stream_id),
+                length,
+                self.conn.max_outbound_frame_size,
+                self.out_bytes_per_second
+            )
+            repeated = b"This is CRT HTTP test."
+            data = int(chunk_size/len(repeated)) * repeated + \
+                repeated[:chunk_size % len(repeated)]
+
+            try:
+                # Sleep for a sec to make the out bytes per second slower than the expected
+                time.sleep(1)
+                self.conn.send_data(
+                    stream_id,
+                    data,
+                    end_stream=(chunk_size == length)
+                )
+            except (StreamClosedError, ProtocolError):
+                # The stream got closed and we didn't get told. We're done
+                # here.
+                break
+
+            self.transport.write(self.conn.data_to_send())
+            length = length - chunk_size
+
+    async def wait_for_flow_control(self, stream_id):
+        """
+        Waits for a Future that fires when the flow control window is opened.
+        """
+        f = asyncio.Future()
+        self.flow_control_futures[stream_id] = f
+        await f
+
+    def window_updated(self, stream_id, delta):
+        """
+        A window update frame was received. Unblock some number of flow control
+        Futures.
+        """
+        if stream_id and stream_id in self.flow_control_futures:
+            f = self.flow_control_futures.pop(stream_id)
+            f.set_result(delta)
+        elif not stream_id:
+            for f in self.flow_control_futures.values():
+                f.set_result(delta)
+
+            self.flow_control_futures = {}
+
+
+ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+ssl_context.options |= (ssl.OP_NO_COMPRESSION)
+ssl_context.load_cert_chain(
+    certfile="../resources/unittests.crt", keyfile="../resources/unittests.key")
+ssl_context.set_alpn_protocols(["h2"])
+
+loop = asyncio.new_event_loop()
+# Each client connection will create a new protocol instance
+coro = loop.create_server(H2Protocol, '127.0.0.1', 8443, ssl=ssl_context)
+server = loop.run_until_complete(coro)
+
+# Serve requests until Ctrl+C is pressed
+print('Serving on {}'.format(server.sockets[0].getsockname()))
+try:
+    loop.run_forever()
+except KeyboardInterrupt:
+    pass
+
+# Close the server
+server.close()
+loop.run_until_complete(server.wait_closed())
+loop.close()

data/aws-crt-ffi/crt/aws-c-http/tests/test_connection_manager.c

@@ -212,7 +212,7 @@ static int s_cm_tester_init(struct cm_tester_options *options) {
         .shutdown_complete_user_data = tester,
         .shutdown_complete_callback = s_cm_tester_on_cm_shutdown_complete,
         .max_connection_idle_in_milliseconds = options->max_connection_idle_in_ms,
-        .prior_knowledge_http2 = !options->use_tls && options->http2,
+        .http2_prior_knowledge = !options->use_tls && options->http2,
         .initial_settings_array = options->initial_settings_array,
         .num_initial_settings = options->num_initial_settings,
     };

data/aws-crt-ffi/crt/aws-c-http/tests/test_connection_monitor.c

@@ -17,7 +17,7 @@
 #include <aws/testing/io_testing_channel.h>
 
 #ifdef _MSC_VER
-#    pragma warning(disable : 4996) /* Disable warnings about sptrintf() being insecure */
+#    pragma warning(disable : 4996) /* Disable warnings about sprintf() being insecure */
 #endif
 
 static int s_test_http_connection_monitor_options_is_valid(struct aws_allocator *allocator, void *ctx) {
@@ -147,7 +147,7 @@ static void s_clean_up_monitor_test(void) {
         if (request_info) {
             aws_http_message_destroy(request_info->request);
             aws_http_stream_release(request_info->stream);
-            aws_input_stream_destroy(request_info->body);
+            aws_input_stream_release(request_info->body);
         }
     }
 

data/aws-crt-ffi/crt/aws-c-http/tests/test_h1_client.c

@@ -33,7 +33,7 @@ static void s_destroy_stream_on_complete(struct aws_http_stream *stream, int err
     (void)stream;
     (void)error_code;
     struct aws_input_stream *data_stream = user_data;
-    aws_input_stream_destroy(data_stream);
+    aws_input_stream_release(data_stream);
 }
 
 static struct aws_http1_chunk_options s_default_chunk_options(struct aws_input_stream *stream, size_t stream_size) {
@@ -274,7 +274,7 @@ H1_CLIENT_TEST_CASE(h1_client_request_send_body) {
     ASSERT_SUCCESS(testing_channel_check_written_messages_str(&tester.testing_channel, allocator, expected));
 
     /* clean up */
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_http_stream_release(stream);
 
@@ -892,7 +892,7 @@ static void s_on_chunk_complete_write_another_chunk(struct aws_http_stream *stre
     AWS_FATAL_ASSERT(0 == error_code);
     struct chunk_that_writes_another *chunk = user_data;
 
-    aws_input_stream_destroy(chunk->body_data);
+    aws_input_stream_release(chunk->body_data);
 
     const struct aws_byte_cursor chunk2_body = aws_byte_cursor_from_c_str("chunk 2.");
     struct aws_input_stream *chunk2_body_stream = aws_input_stream_new_from_cursor(chunk->allocator, &chunk2_body);
@@ -1083,7 +1083,7 @@ H1_CLIENT_TEST_CASE(h1_client_request_content_length_0_ok) {
     ASSERT_SUCCESS(testing_channel_check_written_message_str(&tester.testing_channel, expected));
 
     /* clean up */
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_http_stream_release(stream);
 
@@ -1236,7 +1236,7 @@ H1_CLIENT_TEST_CASE(h1_client_request_send_large_body) {
         &tester.testing_channel, allocator, aws_byte_cursor_from_buf(&expected_buf)));
 
     /* clean up */
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_http_stream_release(stream);
 
@@ -2135,6 +2135,7 @@ H1_CLIENT_TEST_CASE(h1_client_response_with_too_much_data_shuts_down_connection)
 }
 
 struct slow_body_sender {
+    struct aws_input_stream base;
     struct aws_stream_status status;
     struct aws_byte_cursor cursor;
     size_t delay_ticks;    /* Don't send anything the first N ticks */
@@ -2142,7 +2143,7 @@ struct slow_body_sender {
 };
 
 static int s_slow_stream_read(struct aws_input_stream *stream, struct aws_byte_buf *dest) {
-    struct slow_body_sender *sender = stream->impl;
+    struct slow_body_sender *sender = AWS_CONTAINER_OF(stream, struct slow_body_sender, base);
 
     size_t dst_available = dest->capacity - dest->len;
     size_t writing = 0;
@@ -2170,17 +2171,17 @@ static int s_slow_stream_read(struct aws_input_stream *stream, struct aws_byte_b
     return AWS_OP_SUCCESS;
 }
 static int s_slow_stream_get_status(struct aws_input_stream *stream, struct aws_stream_status *status) {
-    struct slow_body_sender *sender = stream->impl;
+    struct slow_body_sender *sender = AWS_CONTAINER_OF(stream, struct slow_body_sender, base);
     *status = sender->status;
     return AWS_OP_SUCCESS;
 }
 static int s_slow_stream_get_length(struct aws_input_stream *stream, int64_t *out_length) {
-    struct slow_body_sender *sender = stream->impl;
+    struct slow_body_sender *sender = AWS_CONTAINER_OF(stream, struct slow_body_sender, base);
     *out_length = sender->cursor.len;
     return AWS_OP_SUCCESS;
 }
 static void s_slow_stream_destroy(struct aws_input_stream *stream) {
-    aws_mem_release(stream->allocator, stream);
+    (void)stream;
 }
 
 static struct aws_input_stream_vtable s_slow_stream_vtable = {
@@ -2188,7 +2189,6 @@ static struct aws_input_stream_vtable s_slow_stream_vtable = {
     .read = s_slow_stream_read,
     .get_status = s_slow_stream_get_status,
     .get_length = s_slow_stream_get_length,
-    .destroy = s_slow_stream_destroy,
 };
 
 /* It should be fine to receive a response before the request has finished sending */
@@ -2198,7 +2198,10 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_done_sending_is_ok
     ASSERT_SUCCESS(s_tester_init(&tester, allocator));
 
     /* set up request whose body won't send immediately */
+    struct aws_input_stream empty_stream_base;
+    AWS_ZERO_STRUCT(empty_stream_base);
     struct slow_body_sender body_sender = {
+        .base = empty_stream_base,
         .status =
             {
                 .is_end_of_stream = false,
@@ -2208,11 +2211,11 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_done_sending_is_ok
         .delay_ticks = 5,
         .bytes_per_tick = 1,
     };
-    struct aws_input_stream body_stream = {
-        .allocator = allocator,
-        .impl = &body_sender,
-        .vtable = &s_slow_stream_vtable,
-    };
+    body_sender.base.vtable = &s_slow_stream_vtable;
+    aws_ref_count_init(
+        &body_sender.base.ref_count, &body_sender, (aws_simple_completion_callback *)s_slow_stream_destroy);
+
+    struct aws_input_stream *body_stream = &body_sender.base;
 
     struct aws_http_header headers[] = {
         {
@@ -2226,7 +2229,7 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_done_sending_is_ok
     ASSERT_SUCCESS(aws_http_message_set_request_method(request, aws_byte_cursor_from_c_str("PUT")));
     ASSERT_SUCCESS(aws_http_message_set_request_path(request, aws_byte_cursor_from_c_str("/plan.txt")));
     ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
-    aws_http_message_set_body_stream(request, &body_stream);
+    aws_http_message_set_body_stream(request, body_stream);
 
     struct client_stream_tester stream_tester;
     ASSERT_SUCCESS(s_stream_tester_init(&stream_tester, &tester, request));
@@ -2236,6 +2239,7 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_done_sending_is_ok
 
     /* Ensure the request can be destroyed after request is sent */
     aws_http_message_destroy(request);
+    aws_input_stream_release(body_stream);
 
     /* send response */
     ASSERT_SUCCESS(testing_channel_push_read_str(&tester.testing_channel, "HTTP/1.1 200 OK\r\n\r\n"));
@@ -2277,7 +2281,10 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_chunks_done_sendin
     ASSERT_SUCCESS(s_tester_init(&tester, allocator));
 
     /* set up request whose body won't send immediately */
+    struct aws_input_stream empty_stream_base;
+    AWS_ZERO_STRUCT(empty_stream_base);
     struct slow_body_sender body_sender = {
+        .base = empty_stream_base,
         .status =
             {
                 .is_end_of_stream = false,
@@ -2287,11 +2294,11 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_chunks_done_sendin
         .delay_ticks = 5,
         .bytes_per_tick = 1,
     };
-    struct aws_input_stream body_stream = {
-        .allocator = allocator,
-        .impl = &body_sender,
-        .vtable = &s_slow_stream_vtable,
-    };
+    body_sender.base.vtable = &s_slow_stream_vtable;
+    aws_ref_count_init(
+        &body_sender.base.ref_count, &body_sender, (aws_simple_completion_callback *)s_slow_stream_destroy);
+
+    struct aws_input_stream *body_stream = &body_sender.base;
 
     struct aws_http_message *request = s_new_default_chunked_put_request(allocator);
     struct client_stream_tester stream_tester;
@@ -2305,13 +2312,14 @@ H1_CLIENT_TEST_CASE(h1_client_response_arrives_before_request_chunks_done_sendin
 
     testing_channel_run_currently_queued_tasks(&tester.testing_channel);
 
-    struct aws_http1_chunk_options options = s_default_chunk_options(&body_stream, body_sender.cursor.len);
+    struct aws_http1_chunk_options options = s_default_chunk_options(body_stream, body_sender.cursor.len);
     options.on_complete = NULL; /* The stream_tester takes care of the stream deletion */
     ASSERT_SUCCESS(aws_http1_stream_write_chunk(stream_tester.stream, &options));
     ASSERT_SUCCESS(s_write_termination_chunk(allocator, stream_tester.stream));
 
     /* Ensure the request can be destroyed after request is sent */
     aws_http_message_destroy(request);
+    aws_input_stream_release(body_stream);
 
     /* tick loop until body finishes sending.*/
     while (body_sender.cursor.len > 0) {
@@ -3060,7 +3068,7 @@ static int s_test_content_length_mismatch_is_error(
     ASSERT_INT_EQUALS(AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT, completion_error_code);
 
     /* clean up */
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_http_stream_release(stream);
 
@@ -3302,11 +3310,13 @@ enum request_callback {
 static const int ERROR_FROM_CALLBACK_ERROR_CODE = (int)0xBEEFCAFE;
 
 struct error_from_callback_tester {
+    struct aws_input_stream base;
     enum request_callback error_at;
     int callback_counts[REQUEST_CALLBACK_COUNT];
     bool has_errored;
     struct aws_stream_status status;
     int on_complete_error_code;
+    struct aws_allocator *alloc;
 };
 
 static int s_error_from_callback_common(
@@ -3330,7 +3340,7 @@ static int s_error_from_outgoing_body_read(struct aws_input_stream *body, struct
 
     (void)dest;
 
-    struct error_from_callback_tester *error_tester = body->impl;
+    struct error_from_callback_tester *error_tester = AWS_CONTAINER_OF(body, struct error_from_callback_tester, base);
     if (s_error_from_callback_common(error_tester, REQUEST_CALLBACK_OUTGOING_BODY)) {
         return AWS_OP_ERR;
     }
@@ -3342,13 +3352,13 @@ static int s_error_from_outgoing_body_read(struct aws_input_stream *body, struct
 }
 
 static int s_error_from_outgoing_body_get_status(struct aws_input_stream *body, struct aws_stream_status *status) {
-    struct error_from_callback_tester *error_tester = body->impl;
+    struct error_from_callback_tester *error_tester = AWS_CONTAINER_OF(body, struct error_from_callback_tester, base);
     *status = error_tester->status;
     return AWS_OP_SUCCESS;
 }
 
 static void s_error_from_outgoing_body_destroy(struct aws_input_stream *stream) {
-    aws_mem_release(stream->allocator, stream);
+    (void)stream;
 }
 
 static struct aws_input_stream_vtable s_error_from_outgoing_body_vtable = {
@@ -3356,7 +3366,6 @@ static struct aws_input_stream_vtable s_error_from_outgoing_body_vtable = {
     .read = s_error_from_outgoing_body_read,
     .get_status = s_error_from_outgoing_body_get_status,
     .get_length = NULL,
-    .destroy = s_error_from_outgoing_body_destroy,
 };
 
 static int s_error_from_incoming_headers(
@@ -3403,7 +3412,10 @@ static int s_test_error_from_callback(struct aws_allocator *allocator, enum requ
     struct tester tester;
     ASSERT_SUCCESS(s_tester_init(&tester, allocator));
 
+    struct aws_input_stream empty_stream_base;
+    AWS_ZERO_STRUCT(empty_stream_base);
     struct error_from_callback_tester error_tester = {
+        .base = empty_stream_base,
         .error_at = error_at,
         .status =
             {
@@ -3411,12 +3423,12 @@ static int s_test_error_from_callback(struct aws_allocator *allocator, enum requ
                 .is_end_of_stream = false,
             },
     };
-    struct aws_input_stream error_from_outgoing_body_stream = {
-        .allocator = allocator,
-        .impl = &error_tester,
-        .vtable = &s_error_from_outgoing_body_vtable,
-    };
-
+    error_tester.base.vtable = &s_error_from_outgoing_body_vtable;
+    aws_ref_count_init(
+        &error_tester.base.ref_count,
+        &error_tester,
+        (aws_simple_completion_callback *)s_error_from_outgoing_body_destroy);
+    struct aws_input_stream *error_from_outgoing_body_stream = &error_tester.base;
     /* send request */
     struct aws_http_header headers[] = {
         {
@@ -3430,7 +3442,7 @@ static int s_test_error_from_callback(struct aws_allocator *allocator, enum requ
     ASSERT_SUCCESS(aws_http_message_set_request_method(request, aws_http_method_post));
     ASSERT_SUCCESS(aws_http_message_set_request_path(request, aws_byte_cursor_from_c_str("/")));
     ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
-    aws_http_message_set_body_stream(request, &error_from_outgoing_body_stream);
+    aws_http_message_set_body_stream(request, error_from_outgoing_body_stream);
 
     struct aws_http_make_request_options opt = {
         .self_size = sizeof(opt),
@@ -3450,6 +3462,7 @@ static int s_test_error_from_callback(struct aws_allocator *allocator, enum requ
 
     /* Ensure the request can be destroyed after request is sent */
     aws_http_message_destroy(opt.request);
+    aws_input_stream_release(error_from_outgoing_body_stream);
 
     /* send response */
     ASSERT_SUCCESS(testing_channel_push_read_str_ignore_errors(

data/aws-crt-ffi/crt/aws-c-http/tests/test_h1_encoder.c

@@ -76,7 +76,7 @@ H1_ENCODER_TEST_CASE(h1_encoder_content_length_put_request_headers) {
     ASSERT_FALSE(encoder_message.has_connection_close_header);
     ASSERT_UINT_EQUALS(body.len, encoder_message.content_length);
 
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_h1_encoder_message_clean_up(&encoder_message);
     aws_h1_encoder_clean_up(&encoder);
@@ -232,7 +232,7 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_not_chunked_put_request_header
     ASSERT_FALSE(encoder_message.has_connection_close_header);
     ASSERT_UINT_EQUALS(0, encoder_message.content_length);
 
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_h1_encoder_message_clean_up(&encoder_message);
     aws_h1_encoder_clean_up(&encoder);
@@ -274,7 +274,7 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_set_body_stream_errors) {
     ASSERT_FALSE(encoder_message.has_connection_close_header);
     ASSERT_UINT_EQUALS(0, encoder_message.content_length);
 
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_h1_encoder_message_clean_up(&encoder_message);
     aws_h1_encoder_clean_up(&encoder);
@@ -396,7 +396,7 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_chunked_and_content_length_put
     ASSERT_INT_EQUALS(
         AWS_OP_ERR, aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list));
 
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     aws_http_message_destroy(request);
     aws_h1_encoder_message_clean_up(&encoder_message);
     aws_h1_encoder_clean_up(&encoder);