Module amqp10_client

Data Types

attach_args()

attach_args() = amqp10_client_session:attach_args()

attach_role()

attach_role() = amqp10_client_session:attach_role()

connection_config()

connection_config() = amqp10_client_connection:connection_config()

filter()

filter() = amqp10_client_session:filter()

link_ref()

abstract datatype: link_ref()

properties()

properties() = amqp10_client_session:properties()

rcv_settle_mode()

rcv_settle_mode() = amqp10_client_session:rcv_settle_mode()

snd_settle_mode()

snd_settle_mode() = amqp10_client_session:snd_settle_mode()

source_def()

source_def() = amqp10_client_session:source_def()

target_def()

target_def() = amqp10_client_session:target_def()

terminus_durability()

terminus_durability() = amqp10_client_session:terminus_durability()

Function Index

accept_msg/2Accept a message on a the link referred to be the 'LinkRef'.
attach_link/2
attach_receiver_link/3Attaches a receiver link to a source.
attach_receiver_link/4Attaches a receiver link to a source.
attach_receiver_link/5Attaches a receiver link to a source.
attach_receiver_link/6Attaches a receiver link to a source.
attach_receiver_link/7Attaches a receiver link to a source.
attach_sender_link/3Attaches a sender link to a target.
attach_sender_link/4Attaches a sender link to a target.
attach_sender_link/5Attaches a sender link to a target.
attach_sender_link_sync/3Synchronously attach a link on 'Session'.
attach_sender_link_sync/4Synchronously attach a link on 'Session'.
attach_sender_link_sync/5Synchronously attach a link on 'Session'.
begin_session/1Begins an amqp10 session using 'Connection'.
begin_session_sync/1Synchronously begins an amqp10 session using 'Connection'.
begin_session_sync/2Synchronously begins an amqp10 session using 'Connection'.
close_connection/1Opens a connection using a connection_config map This is asynchronous and will notify completion to the caller using an amqp10_event of the following format: {amqp10_event, {connection, ConnectionPid, {closed, Why}}}.
detach_link/1Detaches a link.
echo/1Request that the sender's flow state is echoed back This may be used to determine when the Link has finally quiesced.
end_session/1End an amqp10 session.
flow_link_credit/3Grant credit to a sender.
flow_link_credit/4
get_msg/1Get a single message from a link.
get_msg/2Get a single message from a link.
link_handle/1Get the link handle from a LinkRef.
open_connection/1Opens a connection using a connection_config map This is asynchronous and will notify success/closure to the caller using an amqp10_event of the following format: {amqp10_event, {connection, ConnectionPid, opened | {closed, Why}}}.
open_connection/2Convenience function for opening a connection providing only an address and port.
parse_uri/1
send_msg/2Send a message on a the link referred to be the 'LinkRef'.

Function Details

accept_msg/2

accept_msg(Link_ref::link_ref(), Msg::amqp10_msg:amqp10_msg()) -> ok

Accept a message on a the link referred to be the 'LinkRef'.

attach_link/2

attach_link(Session::pid(), AttachArgs::attach_args()) -> {ok, link_ref()}

attach_receiver_link/3

attach_receiver_link(Session::pid(), Name::binary(), Source::binary()) -> {ok, link_ref()}

Attaches a receiver link to a source. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_receiver_link/4

attach_receiver_link(Session::pid(), Name::binary(), Source::binary(), SettleMode::snd_settle_mode()) -> {ok, link_ref()}

Attaches a receiver link to a source. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_receiver_link/5

attach_receiver_link(Session::pid(), Name::binary(), Source::binary(), SettleMode::snd_settle_mode(), Durability::terminus_durability()) -> {ok, link_ref()}

Attaches a receiver link to a source. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_receiver_link/6

attach_receiver_link(Session::pid(), Name::binary(), Source::binary(), SettleMode::snd_settle_mode(), Durability::terminus_durability(), Filter::filter()) -> {ok, link_ref()}

Attaches a receiver link to a source. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_receiver_link/7

attach_receiver_link(Session::pid(), Name::binary(), Source::binary(), SettleMode::snd_settle_mode(), Durability::terminus_durability(), Filter::filter(), Properties::properties()) -> {ok, link_ref()}

Attaches a receiver link to a source. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_sender_link/3

attach_sender_link(Session::pid(), Name::binary(), Target::binary()) -> {ok, link_ref()}

Attaches a sender link to a target. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_sender_link/4

attach_sender_link(Session::pid(), Name::binary(), Target::binary(), SettleMode::snd_settle_mode()) -> {ok, link_ref()}

Attaches a sender link to a target. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_sender_link/5

attach_sender_link(Session::pid(), Name::binary(), Target::binary(), SettleMode::snd_settle_mode(), Durability::terminus_durability()) -> {ok, link_ref()}

Attaches a sender link to a target. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, attached | {detached, Why}}}

attach_sender_link_sync/3

attach_sender_link_sync(Session, Name, Target) -> any()

Synchronously attach a link on 'Session'. This is a convenience function that awaits attached event for the link before returning.

attach_sender_link_sync/4

attach_sender_link_sync(Session::pid(), Name::binary(), Target::binary(), SettleMode::snd_settle_mode()) -> {ok, link_ref()} | link_timeout

Synchronously attach a link on 'Session'. This is a convenience function that awaits attached event for the link before returning.

attach_sender_link_sync/5

attach_sender_link_sync(Session::pid(), Name::binary(), Target::binary(), SettleMode::snd_settle_mode(), Durability::terminus_durability()) -> {ok, link_ref()} | link_timeout

Synchronously attach a link on 'Session'. This is a convenience function that awaits attached event for the link before returning.

begin_session/1

begin_session(Connection::pid()) -> supervisor:startchild_ret()

Begins an amqp10 session using 'Connection'. This is asynchronous and will notify success/closure to the caller using an amqp10_event of the following format: {amqp10_event, {session, SessionPid, begun | {ended, Why}}}

begin_session_sync/1

begin_session_sync(Connection::pid()) -> supervisor:startchild_ret() | session_timeout

Synchronously begins an amqp10 session using 'Connection'. This is a convenience function that awaits the 'begun' event for the newly created session before returning.

begin_session_sync/2

begin_session_sync(Connection::pid(), Timeout::non_neg_integer()) -> supervisor:startchild_ret() | session_timeout

Synchronously begins an amqp10 session using 'Connection'. This is a convenience function that awaits the 'begun' event for the newly created session before returning.

close_connection/1

close_connection(Pid::pid()) -> ok

Opens a connection using a connection_config map This is asynchronous and will notify completion to the caller using an amqp10_event of the following format: {amqp10_event, {connection, ConnectionPid, {closed, Why}}}

detach_link/1

detach_link(Link_ref::link_ref()) -> term()

Detaches a link. This is asynchronous and will notify completion of the attach request to the caller using an amqp10_event of the following format: {amqp10_event, {link, LinkRef, {detached, Why}}}

echo/1

echo(Link_ref) -> any()

Request that the sender's flow state is echoed back This may be used to determine when the Link has finally quiesced. see ยง2.6.10 of the spec

end_session/1

end_session(Pid::pid()) -> ok

End an amqp10 session. This is asynchronous and will notify completion of the end request to the caller using an amqp10_event of the following format: {amqp10_event, {session, SessionPid, {ended, Why}}}

flow_link_credit/3

flow_link_credit(Ref::link_ref(), Credit::non_neg_integer(), RenewWhenBelow::never | non_neg_integer()) -> ok

Grant credit to a sender. The amqp10_client will automatically grant more credit to the sender when the remaining link credit falls below the value of RenewWhenBelow. If RenewWhenBelow is 'never' the client will never grant new credit. Instead the caller will be notified when the link_credit reaches 0 with an amqp10_event of the following format: {amqp10_event, {link, LinkRef, credit_exhausted}}

flow_link_credit/4

flow_link_credit(Link_ref::link_ref(), Credit::non_neg_integer(), RenewWhenBelow::never | non_neg_integer(), Drain::boolean()) -> ok

get_msg/1

get_msg(LinkRef::link_ref()) -> {ok, amqp10_msg:amqp10_msg()} | {error, timeout}

Get a single message from a link. Flows a single link credit then awaits delivery or timeout.

get_msg/2

get_msg(Link_ref::link_ref(), Timeout::non_neg_integer()) -> {ok, amqp10_msg:amqp10_msg()} | {error, timeout}

Get a single message from a link. Flows a single link credit then awaits delivery or timeout.

link_handle/1

link_handle(Link_ref::link_ref()) -> non_neg_integer()

Get the link handle from a LinkRef

open_connection/1

open_connection(ConnectionConfig0::connection_config()) -> supervisor:startchild_ret()

Opens a connection using a connection_config map This is asynchronous and will notify success/closure to the caller using an amqp10_event of the following format: {amqp10_event, {connection, ConnectionPid, opened | {closed, Why}}}

open_connection/2

open_connection(Addr::inet:socket_address() | inet:hostname(), Port::inet:port_number()) -> supervisor:startchild_ret()

Convenience function for opening a connection providing only an address and port. This uses anonymous sasl authentication. This is asynchronous and will notify success/closure to the caller using an amqp10_event of the following format: {amqp10_event, {connection, ConnectionPid, opened | {closed, Why}}}

parse_uri/1

parse_uri(Uri::string()) -> {ok, connection_config()} | {error, term()}

send_msg/2

send_msg(Link_ref::link_ref(), Msg0::amqp10_msg:amqp10_msg()) -> ok | {error, insufficient_credit | link_not_found | half_attached}

Send a message on a the link referred to be the 'LinkRef'. Returns ok for "async" transfers when messages are sent with settled=true else it returns the delivery state from the disposition


Generated by EDoc