aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-c-common/tests/file_test.c

@@ -2,6 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+#include <aws/common/device_random.h>
 #include <aws/common/file.h>
 #include <aws/common/string.h>
 
@@ -439,3 +440,105 @@ static int s_test_normalize_windows_directory_separator(struct aws_allocator *al
 }
 
 AWS_TEST_CASE(test_normalize_windows_directory_separator, s_test_normalize_windows_directory_separator);
+
+static int s_check_byte_buf_from_file(const struct aws_byte_buf *buf, struct aws_byte_cursor expected_contents) {
+    ASSERT_TRUE(aws_byte_cursor_eq_byte_buf(&expected_contents, buf), "Contents should match");
+    ASSERT_TRUE(buf->capacity > buf->len, "Buffer should end with null-terminator");
+    ASSERT_UINT_EQUALS(0, buf->buffer[buf->len], "Buffer should end with null-terminator");
+    return AWS_OP_SUCCESS;
+}
+
+static int s_create_file_then_read_it(struct aws_allocator *allocator, struct aws_byte_cursor contents) {
+    /* create file */
+    const char *filename = "testy";
+    FILE *f = aws_fopen(filename, "wb");
+    ASSERT_UINT_EQUALS(contents.len, fwrite(contents.ptr, 1, contents.len, f));
+    ASSERT_INT_EQUALS(0, fclose(f));
+
+    struct aws_byte_buf buf;
+
+    /* check aws_byte_buf_init_from_file() */
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file(&buf, allocator, filename));
+    ASSERT_SUCCESS(s_check_byte_buf_from_file(&buf, contents));
+    aws_byte_buf_clean_up(&buf);
+
+    /* now check aws_byte_buf_init_from_file_with_size_hint() ... */
+
+    /* size_hint more then big enough */
+    size_t size_hint = contents.len * 2;
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file_with_size_hint(&buf, allocator, filename, size_hint));
+    ASSERT_SUCCESS(s_check_byte_buf_from_file(&buf, contents));
+    aws_byte_buf_clean_up(&buf);
+
+    /* size_hint not big enough for null-terminator */
+    size_hint = contents.len;
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file_with_size_hint(&buf, allocator, filename, size_hint));
+    ASSERT_SUCCESS(s_check_byte_buf_from_file(&buf, contents));
+    aws_byte_buf_clean_up(&buf);
+
+    /* size_hint 0 */
+    size_hint = 0;
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file_with_size_hint(&buf, allocator, filename, size_hint));
+    ASSERT_SUCCESS(s_check_byte_buf_from_file(&buf, contents));
+    aws_byte_buf_clean_up(&buf);
+
+    /* size_hint 1 */
+    size_hint = 1;
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file_with_size_hint(&buf, allocator, filename, size_hint));
+    ASSERT_SUCCESS(s_check_byte_buf_from_file(&buf, contents));
+    aws_byte_buf_clean_up(&buf);
+
+    remove(filename);
+    return AWS_OP_SUCCESS;
+}
+
+/* Read an actual "special file" (if it exists on this machine) */
+static int s_read_special_file(struct aws_allocator *allocator, const char *filename) {
+    struct aws_string *filename_str = aws_string_new_from_c_str(allocator, filename);
+    bool exists = aws_path_exists(filename_str);
+    aws_string_destroy(filename_str);
+    if (!exists) {
+        return AWS_OP_SUCCESS;
+    }
+
+    struct aws_byte_buf buf;
+    ASSERT_SUCCESS(aws_byte_buf_init_from_file(&buf, allocator, filename));
+    ASSERT_TRUE(buf.capacity > buf.len, "Buffer should end with null-terminator");
+    ASSERT_UINT_EQUALS(0, buf.buffer[buf.len], "Buffer should end with null-terminator");
+
+    if (strcmp("/dev/null", filename) == 0) {
+        ASSERT_UINT_EQUALS(0, buf.len, "expected /dev/null to be empty");
+    } else {
+        ASSERT_TRUE(buf.len > 0, "expected special file to have data");
+    }
+
+    aws_byte_buf_clean_up(&buf);
+    return AWS_OP_SUCCESS;
+}
+
+static int s_test_byte_buf_init_from_file(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    /* simple text file */
+    ASSERT_SUCCESS(s_create_file_then_read_it(allocator, aws_byte_cursor_from_c_str("asdf")));
+
+    /* empty file */
+    ASSERT_SUCCESS(s_create_file_then_read_it(allocator, aws_byte_cursor_from_c_str("")));
+
+    /* large 3MB+1byte binary file */
+    struct aws_byte_buf big_rando;
+    aws_byte_buf_init(&big_rando, allocator, (1024 * 1024 * 3) + 1);
+    ASSERT_SUCCESS(aws_device_random_buffer(&big_rando));
+    ASSERT_SUCCESS(s_create_file_then_read_it(allocator, aws_byte_cursor_from_buf(&big_rando)));
+    aws_byte_buf_clean_up(&big_rando);
+
+    /* test some "special files" (if they exist) */
+    ASSERT_SUCCESS(s_read_special_file(allocator, "/proc/cpuinfo"));
+    ASSERT_SUCCESS(s_read_special_file(allocator, "/proc/net/tcp"));
+    ASSERT_SUCCESS(s_read_special_file(allocator, "/sys/devices/virtual/dmi/id/sys_vendor"));
+    ASSERT_SUCCESS(s_read_special_file(allocator, "/dev/null"));
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(test_byte_buf_init_from_file, s_test_byte_buf_init_from_file)

data/aws-crt-ffi/crt/aws-c-common/tests/priority_queue_test.c

@@ -451,6 +451,41 @@ static int s_test_remove_interior_sift_down(struct aws_allocator *allocator, voi
     return 0;
 }
 
+#define BACKPOINTER_CLEAR_NODE_COUNT 16
+
+static int s_priority_queue_clear_backpointers_test(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    struct aws_priority_queue queue;
+
+    ASSERT_SUCCESS(aws_priority_queue_init_dynamic(&queue, allocator, 16, sizeof(int), s_compare_ints));
+
+    struct aws_priority_queue_node queue_nodes[BACKPOINTER_CLEAR_NODE_COUNT];
+
+    for (size_t i = 0; i < BACKPOINTER_CLEAR_NODE_COUNT; ++i) {
+        aws_priority_queue_node_init(&queue_nodes[i]);
+    }
+
+    for (int i = 0; i < BACKPOINTER_CLEAR_NODE_COUNT; i++) {
+        aws_priority_queue_push_ref(&queue, &i, &queue_nodes[i]);
+    }
+
+    for (size_t i = 0; i < BACKPOINTER_CLEAR_NODE_COUNT; ++i) {
+        ASSERT_TRUE(aws_priority_queue_node_is_in_queue(&queue_nodes[i]));
+    }
+
+    aws_priority_queue_clear(&queue);
+    ASSERT_INT_EQUALS(0, aws_priority_queue_size(&queue));
+
+    for (size_t i = 0; i < BACKPOINTER_CLEAR_NODE_COUNT; ++i) {
+        ASSERT_FALSE(aws_priority_queue_node_is_in_queue(&queue_nodes[i]));
+    }
+
+    aws_priority_queue_clean_up(&queue);
+
+    return 0;
+}
+
 AWS_TEST_CASE(priority_queue_remove_interior_sift_down_test, s_test_remove_interior_sift_down);
 AWS_TEST_CASE(priority_queue_remove_interior_sift_up_test, s_test_remove_interior_sift_up);
 AWS_TEST_CASE(priority_queue_remove_leaf_test, s_test_remove_leaf);
@@ -458,3 +493,4 @@ AWS_TEST_CASE(priority_queue_remove_root_test, s_test_remove_root);
 AWS_TEST_CASE(priority_queue_push_pop_order_test, s_test_priority_queue_preserves_order);
 AWS_TEST_CASE(priority_queue_random_values_test, s_test_priority_queue_random_values);
 AWS_TEST_CASE(priority_queue_size_and_capacity_test, s_test_priority_queue_size_and_capacity);
+AWS_TEST_CASE(priority_queue_clear_backpointers_test, s_priority_queue_clear_backpointers_test);

data/aws-crt-ffi/crt/aws-c-common/tests/system_info_tests.c

@@ -166,3 +166,22 @@ static int s_test_sanity_check_numa_discovery(struct aws_allocator *allocator, v
 }
 
 AWS_TEST_CASE(test_sanity_check_numa_discovery, s_test_sanity_check_numa_discovery)
+
+static int s_test_sanity_check_environment_loader(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    aws_common_library_init(allocator);
+    struct aws_system_environment *env = aws_system_environment_load(allocator);
+    ASSERT_NOT_NULL(env);
+    struct aws_byte_cursor virt_vendor = aws_system_environment_get_virtualization_vendor(env);
+    ASSERT_TRUE(aws_byte_cursor_is_valid(&virt_vendor));
+    struct aws_byte_cursor virt_product = aws_system_environment_get_virtualization_product_name(env);
+    ASSERT_TRUE(aws_byte_cursor_is_valid(&virt_product));
+
+    aws_system_environment_release(env);
+
+    aws_common_library_clean_up();
+    return 0;
+}
+
+AWS_TEST_CASE(test_sanity_check_environment_loader, s_test_sanity_check_environment_loader)

data/aws-crt-ffi/crt/aws-c-common/tests/system_resource_util_test.c

@@ -0,0 +1,37 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/byte_buf.h>
+#include <aws/common/device_random.h>
+#include <aws/common/system_resource_util.h>
+
+#include <aws/testing/aws_test_harness.h>
+
+static int s_test_memory_usage_maxrss(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    /*
+     * Note: mem usage apis currently rely on getrusage on posix systems.
+     * On freebsd maxrss seems to return current process rss based on testing,
+     * while on every other posix platform maxrss is high water mark for rss
+     * over the program lifetime.
+     * Workaround it by allocating a buffer first. Long term using procfs should
+     * avoid the issue.
+     */
+    struct aws_byte_buf temp;
+    aws_byte_buf_init(&temp, allocator, 8 * 1024 * 1024);
+    ASSERT_SUCCESS(aws_device_random_buffer(&temp));
+
+    struct aws_memory_usage_stats mu;
+    ASSERT_SUCCESS(aws_init_memory_usage_for_current_process(&mu));
+
+    ASSERT_TRUE(mu.maxrss > 0);
+
+    aws_byte_buf_clean_up_secure(&temp);
+
+    return 0;
+}
+
+AWS_TEST_CASE(test_memory_usage_maxrss, s_test_memory_usage_maxrss)

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

@@ -307,6 +307,15 @@ struct aws_http_client_connection_options {
      */
     const struct aws_http_connection_monitoring_options *monitoring_options;
 
+    /**
+     * Optional (ignored if 0).
+     * After a request is fully sent, if the server does not begin responding within N milliseconds,
+     * then fail with AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT.
+     * This can be overridden per-request by aws_http_make_request_options.response_first_byte_timeout_ms.
+     * TODO: Only supported in HTTP/1.1 now, support it in HTTP/2
+     */
+    uint64_t response_first_byte_timeout_ms;
+
     /**
      * Set to true to manually manage the flow-control window of each stream.
      *

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

@@ -59,6 +59,7 @@ enum aws_http_errors {
     AWS_ERROR_HTTP_WEBSOCKET_PROTOCOL_ERROR,
     AWS_ERROR_HTTP_MANUAL_WRITE_NOT_ENABLED,
     AWS_ERROR_HTTP_MANUAL_WRITE_HAS_COMPLETED,
+    AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT,
 
     AWS_ERROR_HTTP_END_RANGE = AWS_ERROR_ENUM_END_RANGE(AWS_C_HTTP_PACKAGE_ID)
 };

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

@@ -20,10 +20,10 @@ struct aws_http_make_request_options;
 struct aws_http_request_handler_options;
 struct aws_http_stream;
 
-typedef int aws_client_bootstrap_new_socket_channel_fn(struct aws_socket_channel_bootstrap_options *options);
-
+/* vtable of functions that aws_http_connection uses to interact with external systems.
+ * tests override the vtable to mock those systems */
 struct aws_http_connection_system_vtable {
-    aws_client_bootstrap_new_socket_channel_fn *new_socket_channel;
+    int (*aws_client_bootstrap_new_socket_channel)(struct aws_socket_channel_bootstrap_options *options);
 };
 
 struct aws_http_connection_vtable {
@@ -103,7 +103,7 @@ struct aws_http_connection {
 
     union {
         struct aws_http_connection_client_data {
-            uint8_t delete_me; /* exists to prevent "empty struct" errors */
+            uint64_t response_first_byte_timeout_ms;
         } client;
 
         struct aws_http_connection_server_data {
@@ -133,6 +133,7 @@ struct aws_http_client_bootstrap {
     aws_http_on_client_connection_setup_fn *on_setup;
     aws_http_on_client_connection_shutdown_fn *on_shutdown;
     aws_http_proxy_request_transform_fn *proxy_request_transform;
+    uint64_t response_first_byte_timeout_ms;
 
     struct aws_http1_connection_options http1_options;
     struct aws_http2_connection_options http2_options; /* allocated with bootstrap */

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

@@ -12,28 +12,20 @@
 
 struct aws_http_connection_manager;
 
-typedef int(aws_http_connection_manager_create_connection_fn)(const struct aws_http_client_connection_options *options);
-typedef void(aws_http_connection_manager_close_connection_fn)(struct aws_http_connection *connection);
-typedef void(aws_http_connection_release_connection_fn)(struct aws_http_connection *connection);
-typedef bool(aws_http_connection_is_connection_available_fn)(const struct aws_http_connection *connection);
-typedef bool(aws_http_connection_manager_is_callers_thread_fn)(struct aws_channel *channel);
-typedef struct aws_channel *(aws_http_connection_manager_connection_get_channel_fn)(
-    struct aws_http_connection *connection);
-typedef enum aws_http_version(aws_http_connection_manager_connection_get_version_fn)(
-    const struct aws_http_connection *connection);
-
+/* vtable of functions that aws_http_connection_manager uses to interact with external systems.
+ * tests override the vtable to mock those systems */
 struct aws_http_connection_manager_system_vtable {
     /*
      * Downstream http functions
      */
-    aws_http_connection_manager_create_connection_fn *create_connection;
-    aws_http_connection_manager_close_connection_fn *close_connection;
-    aws_http_connection_release_connection_fn *release_connection;
-    aws_http_connection_is_connection_available_fn *is_connection_available;
-    aws_io_clock_fn *get_monotonic_time;
-    aws_http_connection_manager_is_callers_thread_fn *is_callers_thread;
-    aws_http_connection_manager_connection_get_channel_fn *connection_get_channel;
-    aws_http_connection_manager_connection_get_version_fn *connection_get_version;
+    int (*aws_http_client_connect)(const struct aws_http_client_connection_options *options);
+    void (*aws_http_connection_close)(struct aws_http_connection *connection);
+    void (*aws_http_connection_release)(struct aws_http_connection *connection);
+    bool (*aws_http_connection_new_requests_allowed)(const struct aws_http_connection *connection);
+    int (*aws_high_res_clock_get_ticks)(uint64_t *timestamp);
+    bool (*aws_channel_thread_is_callers_thread)(struct aws_channel *channel);
+    struct aws_channel *(*aws_http_connection_get_channel)(struct aws_http_connection *connection);
+    enum aws_http_version (*aws_http_connection_get_version)(const struct aws_http_connection *connection);
 };
 
 AWS_HTTP_API

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

@@ -130,8 +130,12 @@ struct aws_http_proxy_user_data {
     const struct aws_host_resolution_config *host_resolution_config;
 };
 
+/* vtable of functions that proxy uses to interact with external systems.
+ * tests override the vtable to mock those systems */
 struct aws_http_proxy_system_vtable {
-    int (*setup_client_tls)(struct aws_channel_slot *right_of_slot, struct aws_tls_connection_options *tls_options);
+    int (*aws_channel_setup_client_tls)(
+        struct aws_channel_slot *right_of_slot,
+        struct aws_tls_connection_options *tls_options);
 };
 
 AWS_EXTERN_C_BEGIN

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

@@ -6,6 +6,7 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
+#include <aws/common/task_scheduler.h>
 #include <aws/http/request_response.h>
 
 #include <aws/http/private/http_impl.h>
@@ -54,6 +55,10 @@ struct aws_http_stream {
     union {
         struct aws_http_stream_client_data {
             int response_status;
+            uint64_t response_first_byte_timeout_ms;
+            /* Using aws_task instead of aws_channel_task because, currently, channel-tasks can't be canceled.
+             * We only touch this from the connection's thread */
+            struct aws_task response_first_byte_timeout_task;
         } client;
         struct aws_http_stream_server_data {
             struct aws_byte_cursor request_method_str;

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

@@ -300,6 +300,16 @@ struct aws_http_make_request_options {
      * when data has been supplied via `aws_http2_stream_write_data`
      */
     bool http2_use_manual_data_writes;
+
+    /**
+     * Optional (ignored if 0).
+     * After a request is fully sent, if the server does not begin responding within N milliseconds, then fail with
+     * AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT.
+     * It override the connection level settings, when the request completes, the
+     * original monitoring options will be applied back to the connection.
+     * TODO: Only supported in HTTP/1.1 now, support it in HTTP/2
+     */
+    uint64_t response_first_byte_timeout_ms;
 };
 
 struct aws_http_request_handler_options {

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

@@ -27,7 +27,7 @@
 #endif
 
 static struct aws_http_connection_system_vtable s_default_system_vtable = {
-    .new_socket_channel = aws_client_bootstrap_new_socket_channel,
+    .aws_client_bootstrap_new_socket_channel = aws_client_bootstrap_new_socket_channel,
 };
 
 static const struct aws_http_connection_system_vtable *s_system_vtable_ptr = &s_default_system_vtable;
@@ -834,6 +834,8 @@ static void s_client_bootstrap_on_channel_setup(
     }
 
     http_bootstrap->connection->proxy_request_transform = http_bootstrap->proxy_request_transform;
+    http_bootstrap->connection->client_data->response_first_byte_timeout_ms =
+        http_bootstrap->response_first_byte_timeout_ms;
 
     AWS_LOGF_INFO(
         AWS_LS_HTTP_CONNECTION,
@@ -1073,6 +1075,7 @@ int aws_http_client_connect_internal(
     http_bootstrap->proxy_request_transform = proxy_request_transform;
     http_bootstrap->http1_options = *options.http1_options;
     http_bootstrap->http2_options = *options.http2_options;
+    http_bootstrap->response_first_byte_timeout_ms = options.response_first_byte_timeout_ms;
 
     /* keep a copy of the settings array if it's not NULL */
     if (options.http2_options->num_initial_settings > 0) {
@@ -1114,7 +1117,7 @@ int aws_http_client_connect_internal(
         .host_resolution_override_config = options.host_resolution_config,
     };
 
-    err = s_system_vtable_ptr->new_socket_channel(&channel_options);
+    err = s_system_vtable_ptr->aws_client_bootstrap_new_socket_channel(&channel_options);
 
     if (err) {
         AWS_LOGF_ERROR(

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

@@ -43,22 +43,22 @@ struct aws_idle_connection {
  * System vtable to use under normal circumstances
  */
 static struct aws_http_connection_manager_system_vtable s_default_system_vtable = {
-    .create_connection = aws_http_client_connect,
-    .release_connection = aws_http_connection_release,
-    .close_connection = aws_http_connection_close,
-    .is_connection_available = aws_http_connection_new_requests_allowed,
-    .get_monotonic_time = aws_high_res_clock_get_ticks,
-    .is_callers_thread = aws_channel_thread_is_callers_thread,
-    .connection_get_channel = aws_http_connection_get_channel,
-    .connection_get_version = aws_http_connection_get_version,
+    .aws_http_client_connect = aws_http_client_connect,
+    .aws_http_connection_release = aws_http_connection_release,
+    .aws_http_connection_close = aws_http_connection_close,
+    .aws_http_connection_new_requests_allowed = aws_http_connection_new_requests_allowed,
+    .aws_high_res_clock_get_ticks = aws_high_res_clock_get_ticks,
+    .aws_channel_thread_is_callers_thread = aws_channel_thread_is_callers_thread,
+    .aws_http_connection_get_channel = aws_http_connection_get_channel,
+    .aws_http_connection_get_version = aws_http_connection_get_version,
 };
 
 const struct aws_http_connection_manager_system_vtable *g_aws_http_connection_manager_default_system_vtable_ptr =
     &s_default_system_vtable;
 
 bool aws_http_connection_manager_system_vtable_is_valid(const struct aws_http_connection_manager_system_vtable *table) {
-    return table->create_connection && table->close_connection && table->release_connection &&
-           table->is_connection_available;
+    return table->aws_http_client_connect && table->aws_http_connection_close && table->aws_http_connection_release &&
+           table->aws_http_connection_new_requests_allowed;
 }
 
 enum aws_http_connection_manager_state_type { AWS_HCMST_UNINITIALIZED, AWS_HCMST_READY, AWS_HCMST_SHUTTING_DOWN };
@@ -433,13 +433,13 @@ static void s_aws_http_connection_manager_complete_acquisitions(
 
         if (pending_acquisition->error_code == AWS_OP_SUCCESS) {
 
-            struct aws_channel *channel =
-                pending_acquisition->manager->system_vtable->connection_get_channel(pending_acquisition->connection);
+            struct aws_channel *channel = pending_acquisition->manager->system_vtable->aws_http_connection_get_channel(
+                pending_acquisition->connection);
             AWS_PRECONDITION(channel);
 
             /* For some workloads, going ahead and moving the connection callback to the connection's thread is a
              * substantial performance improvement so let's do that */
-            if (!pending_acquisition->manager->system_vtable->is_callers_thread(channel)) {
+            if (!pending_acquisition->manager->system_vtable->aws_channel_thread_is_callers_thread(channel)) {
                 aws_channel_task_init(
                     &pending_acquisition->acquisition_task,
                     s_connection_acquisition_task,
@@ -776,7 +776,7 @@ static void s_schedule_connection_culling(struct aws_http_connection_manager *ma
          * culling interval from now.
          */
         uint64_t now = 0;
-        manager->system_vtable->get_monotonic_time(&now);
+        manager->system_vtable->aws_high_res_clock_get_ticks(&now);
         cull_task_time =
             now + aws_timestamp_convert(
                       manager->max_connection_idle_in_milliseconds, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL);
@@ -1024,7 +1024,7 @@ static int s_aws_http_connection_manager_new_connection(struct aws_http_connecti
         options.proxy_options = &proxy_options;
     }
 
-    if (manager->system_vtable->create_connection(&options)) {
+    if (manager->system_vtable->aws_http_client_connect(&options)) {
         AWS_LOGF_ERROR(
             AWS_LS_HTTP_CONNECTION_MANAGER,
             "id=%p: http connection creation failed with error code %d(%s)",
@@ -1061,7 +1061,7 @@ static void s_aws_http_connection_manager_execute_transaction(struct aws_connect
             "id=%p: Releasing connection (id=%p)",
             (void *)manager,
             (void *)idle_connection->connection);
-        manager->system_vtable->release_connection(idle_connection->connection);
+        manager->system_vtable->aws_http_connection_release(idle_connection->connection);
         aws_mem_release(idle_connection->allocator, idle_connection);
     }
 
@@ -1071,7 +1071,7 @@ static void s_aws_http_connection_manager_execute_transaction(struct aws_connect
             "id=%p: Releasing connection (id=%p)",
             (void *)manager,
             (void *)work->connection_to_release);
-        manager->system_vtable->release_connection(work->connection_to_release);
+        manager->system_vtable->aws_http_connection_release(work->connection_to_release);
     }
 
     /*
@@ -1194,7 +1194,7 @@ static int s_idle_connection(struct aws_http_connection_manager *manager, struct
     idle_connection->connection = connection;
 
     uint64_t idle_start_timestamp = 0;
-    if (manager->system_vtable->get_monotonic_time(&idle_start_timestamp)) {
+    if (manager->system_vtable->aws_high_res_clock_get_ticks(&idle_start_timestamp)) {
         goto on_error;
     }
 
@@ -1223,7 +1223,7 @@ int aws_http_connection_manager_release_connection(
     s_aws_connection_management_transaction_init(&work, manager);
 
     int result = AWS_OP_ERR;
-    bool should_release_connection = !manager->system_vtable->is_connection_available(connection);
+    bool should_release_connection = !manager->system_vtable->aws_http_connection_new_requests_allowed(connection);
 
     AWS_LOGF_DEBUG(
         AWS_LS_HTTP_CONNECTION_MANAGER,
@@ -1413,7 +1413,8 @@ static void s_aws_http_connection_manager_on_connection_setup(
         s_connection_manager_internal_ref_increase(manager, AWS_HCMCT_OPEN_CONNECTION, 1);
     }
 
-    if (connection != NULL && manager->system_vtable->connection_get_version(connection) == AWS_HTTP_VERSION_2) {
+    if (connection != NULL &&
+        manager->system_vtable->aws_http_connection_get_version(connection) == AWS_HTTP_VERSION_2) {
         /* If the manager is shutting down, we will still wait for the settings, since we don't have map for connections
          */
         ++manager->pending_settings_count;
@@ -1492,7 +1493,7 @@ static void s_cull_idle_connections(struct aws_http_connection_manager *manager)
     }
 
     uint64_t now = 0;
-    if (manager->system_vtable->get_monotonic_time(&now)) {
+    if (manager->system_vtable->aws_high_res_clock_get_ticks(&now)) {
         return;
     }