LibAwsEventStream

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

Documentation not found.

__JL_Ctag_201

Documentation not found.

Documentation not found.

Invoked when an aws_event_stream_message is encountered. If the message parsed successfully, message will be non-null and error_code will be AWS_ERROR_SUCCESS. Otherwise message will be null and error_code will represent the error that was encountered. Note that any case that error_code was not AWS_OP_SUCCESS, the channel also shuts down.

Invoked when an aws_event_stream_message is flushed to the IO interface. When error_code is AWS_ERROR_SUCCESS the write happened successfuly. Regardless, message is held from the aws_event_stream_channel_handler_write_message() call and should likely be freed in this callback. If error_code is non-zero, the channel will be shutdown immediately after this callback returns.

aws_event_stream_channel_handler_options

Documentation not found.

aws_event_stream_errors

Documentation not found.

Called by aws_aws_event_stream_streaming_decoder when a header is encountered. 'header' is not yours. Copy the data you want from it if your scope extends beyond your callback.

aws_event_stream_header_value_pair

Documentation not found.

aws_event_stream_header_value_type

Documentation not found.

aws_event_stream_log_subject

Documentation not found.

aws_event_stream_message

Documentation not found.

aws_event_stream_message_prelude

Documentation not found.

Called by aws_aws_event_stream_streaming_decoder when a message decoding is complete and crc is verified.

Called by aws_aws_event_stream_streaming_decoder when an error is encountered. The decoder is not in a good state for usage after this callback.

Called by aws_aws_event_stream_streaming_decoder when a new message has arrived. The prelude will contain metadata about the message. At this point no headers or payload have been received. prelude is copyable.

Called by aws_aws_event_stream_streaming_decoder when payload data has been received. 'data' doesn't belong to you, so copy the data if it is needed beyond the scope of your callback. final_segment == 1 indicates the current data is the last payload buffer for that message.

Documentation not found.

Documentation not found.

aws_event_stream_rpc_client_connection_options

Documentation not found.

Invoked when a non-stream level message is received on a connection.

Documentation not found.

Invoked whenever a message has been flushed to the channel.

Invoked when a connection attempt completes.

If the attempt was unsuccessful, the error_code will be non-zero and the connection pointer will be NULL, and aws_event_stream_rpc_client_on_connection_shutdown_fn will not be invoked.

If the attempt was successful, error_code will be 0 and the connection pointer will be valid. You must call aws_event_stream_rpc_client_connection_acquire() to prevent the pointer's memory from being destroyed before you are ready. When you are completely done with the connection pointer you must call aws_event_stream_rpc_client_connection_release() or its memory will leak. aws_event_stream_rpc_client_on_connection_shutdown_fn will be invoked when the network connection has closed. If you are done with the connection, but it is still open, you must call aws_aws_event_stream_rpc_client_close() or network connection will remain open, even if you call release().

Invoked when a successfully created connection is shutdown. error_code will indicate the reason for the shutdown.

Invoked when a continuation has either been closed with the TERMINATE_STREAM flag, or when the connection shuts down and deletes the continuation.

Invoked when a connection receives a message on an existing stream. message_args contains the message data.

aws_event_stream_rpc_client_stream_continuation_options

Documentation not found.

aws_event_stream_rpc_connection_options

Documentation not found.

aws_event_stream_rpc_message_args

Documentation not found.

aws_event_stream_rpc_message_flag

Documentation not found.

aws_event_stream_rpc_message_type

Documentation not found.

Documentation not found.

Invoked when a non-stream level message is received on a connection.

Documentation not found.

Documentation not found.

aws_event_stream_rpc_server_listener_options

Documentation not found.

Invoked whenever a message has been flushed to the channel.

Invoked when a successfully created connection is shutdown. error_code will indicate the reason for the shutdown.

Invoked when a new stream has been received on the connection. If you return AWS_OP_SUCCESS (0), You must fill in the fields for continuation options or the program will assert and exit.

A failure path MUST leave the ref count of the continuation alone.

A success path should probably take a ref which will leave the continuation (assuming no other interference) at two AFTER creation is complete: 1 for the connection's continuation table, and one for the callback recipient which is presumably tracking it as well.

(Optional). Invoked when the listener has been successfully shutdown (after the last ref count release).

Invoked when a new connection is received on a server listener. If you return AWS_OP_SUCCESS, You must fill in the fields for connection_options or the program will assert and exit.

If error_code is non-zero, an error occurred upon setting up the channel and connection will be NULL. Otherwise, connection is non-null. If you intend to seat a pointer to connection, you MUST call aws_event_stream_rpc_server_connection_acquire() and when you're finished with the connection you MUST call aws_event_stream_server_connection_release().

Invoked when a continuation has either been closed with the TERMINATE_STREAM flag, or when the connection shutsdown and deletes the continuation.

Invoked when a connection receives a message on an existing stream. message_args contains the message data.

aws_event_stream_rpc_server_stream_continuation_options

Documentation not found.

aws_event_stream_streaming_decoder

Documentation not found.

aws_event_stream_streaming_decoder_options

Documentation not found.

aws_event_stream_add_bool_header(headers, name, name_len, value)

Adds a bool header to the list of headers.

Prototype

int aws_event_stream_add_bool_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int8_t value);

aws_event_stream_add_bool_header_by_cursor(headers, name, value)

Adds a boolean-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_bool_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, bool value);

aws_event_stream_add_byte_buf_header_by_cursor(headers, name, value)

Adds a byte_buf-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_byte_buf_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, struct aws_byte_cursor value);

aws_event_stream_add_byte_header(headers, name, name_len, value)

Adds a byte header to the list of headers.

Prototype

int aws_event_stream_add_byte_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int8_t value);

aws_event_stream_add_byte_header_by_cursor(headers, name, value)

Adds a byte-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_byte_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, int8_t value);

aws_event_stream_add_bytebuf_header(headers, name, name_len, value, value_len, copy)

Adds a byte-buffer header to the list of headers. If copy is set to true, this will result in an allocation for the header value. Otherwise, the value will be set to the memory address of 'value'.

Prototype

int aws_event_stream_add_bytebuf_header( struct aws_array_list *headers, const char *name, uint8_t name_len, uint8_t *value, uint16_t value_len, int8_t copy);

aws_event_stream_add_header(headers, header)

Adds a generic header to the list of headers. Makes a copy of the underlaying data.

Prototype

int aws_event_stream_add_header( struct aws_array_list *headers, const struct aws_event_stream_header_value_pair *header);

aws_event_stream_add_int16_header(headers, name, name_len, value)

adds a 16 bit integer to the list of headers.

Prototype

int aws_event_stream_add_int16_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int16_t value);

aws_event_stream_add_int16_header_by_cursor(headers, name, value)

Adds a int16-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_int16_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, int16_t value);

aws_event_stream_add_int32_header(headers, name, name_len, value)

adds a 32 bit integer to the list of headers.

Prototype

int aws_event_stream_add_int32_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int32_t value);

aws_event_stream_add_int32_header_by_cursor(headers, name, value)

Adds a int32-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_int32_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, int32_t value);

aws_event_stream_add_int64_header(headers, name, name_len, value)

adds a 64 bit integer to the list of headers.

Prototype

int aws_event_stream_add_int64_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int64_t value);

aws_event_stream_add_int64_header_by_cursor(headers, name, value)

Adds a int64-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_int64_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, int64_t value);

aws_event_stream_add_string_header(headers, name, name_len, value, value_len, copy)

Adds a string header to the list of headers. If copy is set to true, this will result in an allocation for the header value. Otherwise, the value will be set to the memory address of 'value'.

Prototype

int aws_event_stream_add_string_header( struct aws_array_list *headers, const char *name, uint8_t name_len, const char *value, uint16_t value_len, int8_t copy);

aws_event_stream_add_string_header_by_cursor(headers, name, value)

Adds a string-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_string_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, struct aws_byte_cursor value);

aws_event_stream_add_timestamp_header(headers, name, name_len, value)

adds a 64 bit integer representing milliseconds since unix epoch to the list of headers.

Prototype

int aws_event_stream_add_timestamp_header( struct aws_array_list *headers, const char *name, uint8_t name_len, int64_t value);

aws_event_stream_add_timestamp_header_by_cursor(headers, name, value)

Adds a timestamp-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_timestamp_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, int64_t value);

aws_event_stream_add_uuid_header(headers, name, name_len, value)

adds a uuid buffer to the list of headers. Value must always be 16 bytes long.

Prototype

int aws_event_stream_add_uuid_header( struct aws_array_list *headers, const char *name, uint8_t name_len, const uint8_t *value);

aws_event_stream_add_uuid_header_by_cursor(headers, name, value)

Adds a uuid-valued header to a header list

Arguments

• headers: header list to add to
• name: name of the header to add
• value: value of the header to add

Returns

AWS_OP_SUCCESS on success, AWS_OP_ERR on failure

Prototype

int aws_event_stream_add_uuid_header_by_cursor( struct aws_array_list *headers, struct aws_byte_cursor name, struct aws_byte_cursor value);

aws_event_stream_channel_handler_get_user_data(handler)

Documentation not found.

Prototype

void *aws_event_stream_channel_handler_get_user_data(struct aws_channel_handler *handler);

aws_event_stream_channel_handler_increment_read_window(handler, window_update_size)

Updates the read window for the channel if automatic_window_managemanet was set to false.

Prototype

void aws_event_stream_channel_handler_increment_read_window( struct aws_channel_handler *handler, size_t window_update_size);

aws_event_stream_channel_handler_new(allocator, handler_options)

Allocates and initializes a new channel handler for processing aws_event_stream_message() events. Handler options must not be null.

Prototype

struct aws_channel_handler *aws_event_stream_channel_handler_new( struct aws_allocator *allocator, const struct aws_event_stream_channel_handler_options *handler_options);

aws_event_stream_channel_handler_write_message(handler, message, on_message_written, user_data)

Writes an aws_event_stream_message() to the channel. Once the channel flushes or an error occurs, on_message_written will be invoked. message should stay valid until the callback is invoked. If an error an occurs, the channel will automatically be shutdown.

Prototype

int aws_event_stream_channel_handler_write_message( struct aws_channel_handler *handler, struct aws_event_stream_message *message, aws_event_stream_channel_handler_on_message_written_fn *on_message_written, void *user_data);

aws_event_stream_compute_headers_required_buffer_len(headers)

Documentation not found.

Prototype

uint32_t aws_event_stream_compute_headers_required_buffer_len(const struct aws_array_list *headers);

aws_event_stream_create_int32_header(name, value)

Documentation not found.

Prototype

struct aws_event_stream_header_value_pair aws_event_stream_create_int32_header( struct aws_byte_cursor name, int32_t value);

aws_event_stream_create_string_header(name, value)

Documentation not found.

Prototype

struct aws_event_stream_header_value_pair aws_event_stream_create_string_header( struct aws_byte_cursor name, struct aws_byte_cursor value);

aws_event_stream_header_name(header)

Returns the header name. Note: this value is not null terminated

Prototype

struct aws_byte_buf aws_event_stream_header_name( struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_bool(header)

Returns the header value as a boolean value.

Prototype

int8_t aws_event_stream_header_value_as_bool(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_byte(header)

Returns the header value as a byte

Prototype

int8_t aws_event_stream_header_value_as_byte(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_bytebuf(header)

Returns the header value as a pointer to a byte buffer, call aws_event_stream_header_value_length to determine the length of the buffer.

Prototype

struct aws_byte_buf aws_event_stream_header_value_as_bytebuf( struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_int16(header)

Returns the header value as a 16 bit integer.

Prototype

int16_t aws_event_stream_header_value_as_int16(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_int32(header)

Returns the header value as a 32 bit integer.

Prototype

int32_t aws_event_stream_header_value_as_int32(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_int64(header)

Returns the header value as a 64 bit integer.

Prototype

int64_t aws_event_stream_header_value_as_int64(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_string(header)

Returns the header value as a string. Note: this value is not null terminated.

Prototype

struct aws_byte_buf aws_event_stream_header_value_as_string( struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_timestamp(header)

Returns the header value as a 64 bit integer representing milliseconds since unix epoch.

Prototype

int64_t aws_event_stream_header_value_as_timestamp(struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_as_uuid(header)

Returns the header value a byte buffer which is 16 bytes long. Represents a UUID.

Prototype

struct aws_byte_buf aws_event_stream_header_value_as_uuid( struct aws_event_stream_header_value_pair *header);

aws_event_stream_header_value_length(header)

Returns the length of the header value buffer. This is mostly intended for string and byte buffer types.

Prototype

uint16_t aws_event_stream_header_value_length(struct aws_event_stream_header_value_pair *header);

aws_event_stream_headers_list_cleanup(headers)

Cleans up the headers list. Also deallocates any headers that were the result of a copy flag for strings or buffer.

Prototype

void aws_event_stream_headers_list_cleanup(struct aws_array_list *headers);

aws_event_stream_headers_list_init(headers, allocator)

initializes a headers list for you. It will default to a capacity of 4 in dynamic mode.

Prototype

int aws_event_stream_headers_list_init( struct aws_array_list *headers, struct aws_allocator *allocator);

aws_event_stream_library_clean_up()

Clean up internal datastructures used by aws-c-event-stream. Must not be called until application is done using functionality in aws-c-event-stream.

Prototype

void aws_event_stream_library_clean_up(void);

aws_event_stream_library_init(allocator)

Initializes internal datastructures used by aws-c-event-stream. Must be called before using any functionality in aws-c-event-stream.

Prototype

void aws_event_stream_library_init(struct aws_allocator *allocator);

aws_event_stream_message_buffer(message)

Returns the message as a buffer ready for transport.

Prototype

const uint8_t *aws_event_stream_message_buffer(const struct aws_event_stream_message *message);

aws_event_stream_message_clean_up(message)

Cleans up any internally allocated memory. Always call this for API compatibility reasons, even if you only used the aws_aws_event_stream_message_from_buffer function.

Prototype

void aws_event_stream_message_clean_up(struct aws_event_stream_message *message);

aws_event_stream_message_from_buffer(message, alloc, buffer)

Zero allocation, Zero copy. The message will simply wrap the buffer. The message functions are only useful as long as buffer is referencable memory.

Prototype

int aws_event_stream_message_from_buffer( struct aws_event_stream_message *message, struct aws_allocator *alloc, struct aws_byte_buf *buffer);

aws_event_stream_message_from_buffer_copy(message, alloc, buffer)

Allocates memory and copies buffer. Otherwise the same as aws_aws_event_stream_message_from_buffer. This is slower, but possibly safer.

Prototype

int aws_event_stream_message_from_buffer_copy( struct aws_event_stream_message *message, struct aws_allocator *alloc, const struct aws_byte_buf *buffer);

aws_event_stream_message_headers(message, headers)

Adds the headers for the message to list. The memory in each header is owned as part of the message, do not free it or pass its address around.

Prototype

int aws_event_stream_message_headers( const struct aws_event_stream_message *message, struct aws_array_list *headers);

aws_event_stream_message_headers_len(message)

Returns the length of the headers portion of the message.

Prototype

uint32_t aws_event_stream_message_headers_len(const struct aws_event_stream_message *message);

aws_event_stream_message_init(message, alloc, headers, payload)

Initializes with a list of headers, the payload, and a payload length. CRCs will be computed for you. If headers or payload is NULL, then the fields will be appropriately set to indicate no headers and/or no payload. Both payload and headers will result in an allocation.

Prototype

int aws_event_stream_message_init( struct aws_event_stream_message *message, struct aws_allocator *alloc, const struct aws_array_list *headers, const struct aws_byte_buf *payload);

aws_event_stream_message_message_crc(message)

Returns the checksum of the entire message (crc32)

Prototype

uint32_t aws_event_stream_message_message_crc(const struct aws_event_stream_message *message);

aws_event_stream_message_payload(message)

Returns a pointer to the beginning of the message payload.

Prototype

const uint8_t *aws_event_stream_message_payload(const struct aws_event_stream_message *message);

aws_event_stream_message_payload_len(message)

Returns the length of the message payload.

Prototype

uint32_t aws_event_stream_message_payload_len(const struct aws_event_stream_message *message);

aws_event_stream_message_prelude_crc(message)

Returns the prelude crc (crc32)

Prototype

uint32_t aws_event_stream_message_prelude_crc(const struct aws_event_stream_message *message);

aws_event_stream_message_to_debug_str(fd, message)

Writes the message to fd in json format. All strings and binary fields are base64 encoded.

Prototype

int aws_event_stream_message_to_debug_str( FILE *fd, const struct aws_event_stream_message *message);

aws_event_stream_message_total_length(message)

Returns the total length of the message (including the length field).

Prototype

uint32_t aws_event_stream_message_total_length(const struct aws_event_stream_message *message);

aws_event_stream_read_headers_from_buffer(headers, buffer, headers_len)

Get the headers from the buffer, store them in the headers list. the user's responsibility to cleanup the list when they are finished with it. no buffer copies happen here, the lifetime of the buffer, must outlive the usage of the headers. returns error codes defined in the public interface.

Prototype

int aws_event_stream_read_headers_from_buffer( struct aws_array_list *headers, const uint8_t *buffer, size_t headers_len);

aws_event_stream_rpc_client_connection_acquire(connection)

Documentation not found.

Prototype

void aws_event_stream_rpc_client_connection_acquire( const struct aws_event_stream_rpc_client_connection *connection);

aws_event_stream_rpc_client_connection_close(connection, shutdown_error_code)

Closes the connection if it is open and aws_event_stream_rpc_client_connection_options::on_connection_shutdown will be invoked upon shutdown. shutdown_error_code will indicate the reason for shutdown. For a graceful shutdown pass 0 or AWS_ERROR_SUCCESS.

Prototype

void aws_event_stream_rpc_client_connection_close( struct aws_event_stream_rpc_client_connection *connection, int shutdown_error_code);

aws_event_stream_rpc_client_connection_connect(allocator, conn_options)

Initiate a new connection. If this function returns AWS_OP_SUCESSS, the aws_event_stream_rpc_client_connection_options::on_connection_setup is guaranteed to be called exactly once. If that callback successfully creates a connection, aws_event_stream_rpc_client_connection_options::on_connection_shutdown will be invoked upon connection closure. However if the connection was never successfully setup, aws_event_stream_rpc_client_connection_options::on_connection_shutdown will not be invoked later.

Prototype

int aws_event_stream_rpc_client_connection_connect( struct aws_allocator *allocator, const struct aws_event_stream_rpc_client_connection_options *conn_options);

aws_event_stream_rpc_client_connection_is_open(connection)

Returns true if the connection is open, false otherwise.

Prototype

bool aws_event_stream_rpc_client_connection_is_open( const struct aws_event_stream_rpc_client_connection *connection);

aws_event_stream_rpc_client_connection_new_stream(connection, continuation_options)

Create a new stream. continuation_option's callbacks will not be invoked, and nothing will be sent across the wire until aws_event_stream_rpc_client_continuation_activate() is invoked.

returns an instance of a aws_event_stream_rpc_client_continuation_token on success with a reference count of 1. You must call aws_event_stream_rpc_client_continuation_release() when you're finished with it. Returns NULL on failure.

Prototype

struct aws_event_stream_rpc_client_continuation_token * aws_event_stream_rpc_client_connection_new_stream( struct aws_event_stream_rpc_client_connection *connection, const struct aws_event_stream_rpc_client_stream_continuation_options *continuation_options);

aws_event_stream_rpc_client_connection_release(connection)

Documentation not found.

Prototype

void aws_event_stream_rpc_client_connection_release( const struct aws_event_stream_rpc_client_connection *connection);

aws_event_stream_rpc_client_connection_send_protocol_message(connection, message_args, flush_fn, user_data)

Sends a message on the connection. These must be connection level messages (not application messages).

flush_fn will be invoked when the message has been successfully writen to the wire or when it fails.

returns AWS_OP_SUCCESS if the message was successfully created and queued, and in that case flush_fn will always be invoked. Otherwise, flush_fn will not be invoked.

Prototype

int aws_event_stream_rpc_client_connection_send_protocol_message( struct aws_event_stream_rpc_client_connection *connection, const struct aws_event_stream_rpc_message_args *message_args, aws_event_stream_rpc_client_message_flush_fn *flush_fn, void *user_data);

aws_event_stream_rpc_client_continuation_acquire(continuation)

Documentation not found.

Prototype

void aws_event_stream_rpc_client_continuation_acquire( const struct aws_event_stream_rpc_client_continuation_token *continuation);

aws_event_stream_rpc_client_continuation_activate(continuation, operation_name, message_args, flush_fn, user_data)

Actually sends the initial stream to the peer. Callbacks from aws_event_stream_rpc_client_connection_new_stream() will actually be invoked if this function returns AWS_OP_SUCCESS, otherwise, the stream has not been queued and no callbacks will be invoked.

operation_name is the name to identify which logical rpc call you want to kick off with the peer. It must be non-empty. flush_fn will be invoked once the message has either been written to the wire or it fails.

Prototype

int aws_event_stream_rpc_client_continuation_activate( struct aws_event_stream_rpc_client_continuation_token *continuation, struct aws_byte_cursor operation_name, const struct aws_event_stream_rpc_message_args *message_args, aws_event_stream_rpc_client_message_flush_fn *flush_fn, void *user_data);

aws_event_stream_rpc_client_continuation_get_user_data(continuation)

Documentation not found.

Prototype

void *aws_event_stream_rpc_client_continuation_get_user_data( struct aws_event_stream_rpc_client_continuation_token *continuation);

aws_event_stream_rpc_client_continuation_is_closed(continuation)

returns true if the continuation has been closed.

Prototype

bool aws_event_stream_rpc_client_continuation_is_closed( const struct aws_event_stream_rpc_client_continuation_token *continuation);

aws_event_stream_rpc_client_continuation_release(continuation)

Documentation not found.

Prototype

void aws_event_stream_rpc_client_continuation_release( const struct aws_event_stream_rpc_client_continuation_token *continuation);

aws_event_stream_rpc_client_continuation_send_message(continuation, message_args, flush_fn, user_data)

Sends a message on the continuation. aws_event_stream_rpc_client_continuation_activate() must be successfully invoked prior to calling this function.

If this function returns AWS_OP_SUCCESS, flush_fn will be invoked once the message has either been written to the wire or it fails.

Prototype

int aws_event_stream_rpc_client_continuation_send_message( struct aws_event_stream_rpc_client_continuation_token *continuation, const struct aws_event_stream_rpc_message_args *message_args, aws_event_stream_rpc_client_message_flush_fn *flush_fn, void *user_data);

aws_event_stream_rpc_server_connection_acquire(connection)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_connection_acquire( struct aws_event_stream_rpc_server_connection *connection);

aws_event_stream_rpc_server_connection_close(connection, shutdown_error_code)

Closes the connection (including all continuations on the connection), and releases the connection ref count. shutdown_error_code is the error code to use when shutting down the channel. Use AWS_ERROR_SUCCESS for non-error cases.

Prototype

void aws_event_stream_rpc_server_connection_close( struct aws_event_stream_rpc_server_connection *connection, int shutdown_error_code);

aws_event_stream_rpc_server_connection_from_existing_channel(server, channel, connection_options)

Bypasses server, and creates a connection on an already existing channel. No connection lifetime callbacks will be invoked on the returned connection. Returns NULL if an error occurs. If and only if, you use this API, the returned connection is already ref counted and you must call aws_event_stream_rpc_server_connection_release() even if you did not explictly call aws_event_stream_rpc_server_connection_acquire()

Prototype

struct aws_event_stream_rpc_server_connection * aws_event_stream_rpc_server_connection_from_existing_channel( struct aws_event_stream_rpc_server_listener *server, struct aws_channel *channel, const struct aws_event_stream_rpc_connection_options *connection_options);

aws_event_stream_rpc_server_connection_get_user_data(connection)

Documentation not found.

Prototype

void *aws_event_stream_rpc_server_connection_get_user_data( struct aws_event_stream_rpc_server_connection *connection);

aws_event_stream_rpc_server_connection_is_open(connection)

returns true if the connection is open. False otherwise.

Prototype

bool aws_event_stream_rpc_server_connection_is_open( struct aws_event_stream_rpc_server_connection *connection);

aws_event_stream_rpc_server_connection_release(connection)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_connection_release( struct aws_event_stream_rpc_server_connection *connection);

aws_event_stream_rpc_server_connection_send_protocol_message(connection, message_args, flush_fn, user_data)

Sends a protocol message on the connection (not application data). If the message is valid and successfully written to the channel, flush_fn will be invoked.

Prototype

int aws_event_stream_rpc_server_connection_send_protocol_message( struct aws_event_stream_rpc_server_connection *connection, const struct aws_event_stream_rpc_message_args *message_args, aws_event_stream_rpc_server_message_flush_fn *flush_fn, void *user_data);

aws_event_stream_rpc_server_continuation_acquire(continuation)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_continuation_acquire( struct aws_event_stream_rpc_server_continuation_token *continuation);

aws_event_stream_rpc_server_continuation_is_closed(continuation)

returns true if the continuation is still in an open state.

Prototype

bool aws_event_stream_rpc_server_continuation_is_closed( struct aws_event_stream_rpc_server_continuation_token *continuation);

aws_event_stream_rpc_server_continuation_release(continuation)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_continuation_release( struct aws_event_stream_rpc_server_continuation_token *continuation);

aws_event_stream_rpc_server_continuation_send_message(continuation, message_args, flush_fn, user_data)

Sends an application message on the continuation. If the message is valid and successfully written to the channel, flush_fn will be invoked.

Prototype

int aws_event_stream_rpc_server_continuation_send_message( struct aws_event_stream_rpc_server_continuation_token *continuation, const struct aws_event_stream_rpc_message_args *message_args, aws_event_stream_rpc_server_message_flush_fn *flush_fn, void *user_data);

aws_event_stream_rpc_server_listener_acquire(listener)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_listener_acquire( struct aws_event_stream_rpc_server_listener *listener);

aws_event_stream_rpc_server_listener_get_bound_port(listener)

Get the local port which the listener's socket is bound to.

Prototype

uint32_t aws_event_stream_rpc_server_listener_get_bound_port( const struct aws_event_stream_rpc_server_listener *listener);

aws_event_stream_rpc_server_listener_release(listener)

Documentation not found.

Prototype

void aws_event_stream_rpc_server_listener_release( struct aws_event_stream_rpc_server_listener *listener);

aws_event_stream_rpc_server_new_listener(allocator, options)

Creates a listener with a ref count of 1. You are responsible for calling aws_event_stream_rpc_server_listener_release() when you're finished with the listener. Returns NULL if an error occurs.

Prototype

struct aws_event_stream_rpc_server_listener *aws_event_stream_rpc_server_new_listener( struct aws_allocator *allocator, struct aws_event_stream_rpc_server_listener_options *options);

aws_event_stream_streaming_decoder_clean_up(decoder)

Currently, no memory is allocated inside aws_aws_event_stream_streaming_decoder, but for future API compatibility, you should call this when finished with it.

Prototype

void aws_event_stream_streaming_decoder_clean_up( struct aws_event_stream_streaming_decoder *decoder);

aws_event_stream_streaming_decoder_init(decoder, alloc, on_payload_segment, on_prelude, on_header, on_error, user_data)

Deprecated. Use aws_event_stream_streaming_decoder_init_from_options instead. Initialize a streaming decoder for messages with callbacks for usage and an optional user context pointer.

Prototype

void aws_event_stream_streaming_decoder_init( struct aws_event_stream_streaming_decoder *decoder, struct aws_allocator *alloc, aws_event_stream_process_on_payload_segment_fn *on_payload_segment, aws_event_stream_prelude_received_fn *on_prelude, aws_event_stream_header_received_fn *on_header, aws_event_stream_on_error_fn *on_error, void *user_data);

aws_event_stream_streaming_decoder_init_from_options(decoder, allocator, options)

Initialize a streaming decoder for messages with callbacks for usage and an optional user context pointer.

Prototype

void aws_event_stream_streaming_decoder_init_from_options( struct aws_event_stream_streaming_decoder *decoder, struct aws_allocator *allocator, const struct aws_event_stream_streaming_decoder_options *options);

aws_event_stream_streaming_decoder_pump(decoder, data)

The main driver of the decoder. Pass data that should be decoded with its length. A likely use-case here is in response to a read event from an io-device

Prototype

int aws_event_stream_streaming_decoder_pump( struct aws_event_stream_streaming_decoder *decoder, const struct aws_byte_buf *data);

aws_event_stream_write_headers_to_buffer(headers, buffer)

Deprecated in favor of 'aws_event_stream_write_headers_to_buffer_safe' as this API is unsafe.

Writes headers to buffer and returns the length of bytes written to buffer. Assumes buffer is large enough to store the headers.

Prototype

size_t aws_event_stream_write_headers_to_buffer(const struct aws_array_list *headers, uint8_t *buffer);

aws_event_stream_write_headers_to_buffer_safe(headers, buf)

Writes headers to buf assuming buf is large enough to hold the data. Prefer this function over the unsafe variant 'aws_event_stream_write_headers_to_buffer'.

Returns AWS_OP_SUCCESS if the headers were successfully and completely written and AWS_OP_ERR otherwise.

Prototype

int aws_event_stream_write_headers_to_buffer_safe( const struct aws_array_list *headers, struct aws_byte_buf *buf);