Noratrieb/haesli
1
0
Fork 0
mirror of https://github.com/Noratrieb/haesli.git synced 2026-01-17 05:05:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

more cleanup

Browse source
This commit is contained in:
nora 2022-02-26 23:47:47 +01:00
parent 439696cf3f
commit 14ad4e1011
11 changed files with 1199 additions and 1048 deletions
Download patch file Download diff file Expand all files Collapse all files

579
amqp_core/src/methods/generated.rs
View file

@ -126,151 +126,236 @@ pub type Table = super::Table;
#[derive(Debug, Clone, PartialEq)]
pub enum Method {
ConnectionStart(ConnectionStart),
ConnectionStartOk(ConnectionStartOk),
ConnectionSecure(ConnectionSecure),
ConnectionSecureOk(ConnectionSecureOk),
ConnectionTune(ConnectionTune),
ConnectionTuneOk(ConnectionTuneOk),
ConnectionOpen(ConnectionOpen),
ConnectionOpenOk(ConnectionOpenOk),
ConnectionClose(ConnectionClose),
ConnectionCloseOk(ConnectionCloseOk),
ChannelOpen(ChannelOpen),
ChannelOpenOk(ChannelOpenOk),
ChannelFlow(ChannelFlow),
ChannelFlowOk(ChannelFlowOk),
ChannelClose(ChannelClose),
ChannelCloseOk(ChannelCloseOk),
ExchangeDeclare(ExchangeDeclare),
ExchangeDeclareOk(ExchangeDeclareOk),
ExchangeDelete(ExchangeDelete),
ExchangeDeleteOk(ExchangeDeleteOk),
QueueDeclare(QueueDeclare),
QueueDeclareOk(QueueDeclareOk),
QueueBind(QueueBind),
QueueBindOk(QueueBindOk),
QueueUnbind(QueueUnbind),
QueueUnbindOk(QueueUnbindOk),
QueuePurge(QueuePurge),
QueuePurgeOk(QueuePurgeOk),
QueueDelete(QueueDelete),
QueueDeleteOk(QueueDeleteOk),
BasicQos(BasicQos),
BasicQosOk(BasicQosOk),
BasicConsume(BasicConsume),
BasicConsumeOk(BasicConsumeOk),
BasicCancel(BasicCancel),
BasicCancelOk(BasicCancelOk),
BasicPublish(BasicPublish),
BasicReturn(BasicReturn),
BasicDeliver(BasicDeliver),
BasicGet(BasicGet),
BasicGetOk(BasicGetOk),
BasicGetEmpty(BasicGetEmpty),
BasicAck(BasicAck),
BasicReject(BasicReject),
BasicRecoverAsync(BasicRecoverAsync),
BasicRecover(BasicRecover),
BasicRecoverOk(BasicRecoverOk),
TxSelect(TxSelect),
TxSelectOk(TxSelectOk),
TxCommit(TxCommit),
TxCommitOk(TxCommitOk),
TxRollback(TxRollback),
TxRollbackOk(TxRollbackOk),
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method starts the connection negotiation process by telling the client the
/// protocol version that the server proposes, along with a list of security mechanisms
/// which the client can use for authentication.
ConnectionStart {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionStart {
/// The major version number can take any value from 0 to 99 as defined in the
/// AMQP specification.
version_major: Octet,
pub version_major: Octet,
/// The minor version number can take any value from 0 to 99 as defined in the
/// AMQP specification.
version_minor: Octet,
server_properties: PeerProperties,
pub version_minor: Octet,
pub server_properties: PeerProperties,
/// must not be null
///
/// A list of the security mechanisms that the server supports, delimited by spaces.
mechanisms: Longstr,
pub mechanisms: Longstr,
/// must not be null
///
/// A list of the message locales that the server supports, delimited by spaces. The
/// locale defines the language in which the server will send reply texts.
locales: Longstr,
},
pub locales: Longstr,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method selects a SASL security mechanism.
ConnectionStartOk {
client_properties: PeerProperties,
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionStartOk {
pub client_properties: PeerProperties,
/// must not be null
///
/// A single security mechanisms selected by the client, which must be one of those
/// specified by the server.
mechanism: Shortstr,
pub mechanism: Shortstr,
/// must not be null
///
/// A block of opaque data passed to the security mechanism. The contents of this
/// data are defined by the SASL security mechanism.
response: Longstr,
pub response: Longstr,
/// must not be null
///
/// A single message locale selected by the client, which must be one of those
/// specified by the server.
locale: Shortstr,
},
pub locale: Shortstr,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// The SASL protocol works by exchanging challenges and responses until both peers have
/// received sufficient information to authenticate each other. This method challenges
/// the client to provide more information.
ConnectionSecure {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionSecure {
/// Challenge information, a block of opaque binary data passed to the security
/// mechanism.
challenge: Longstr,
},
pub challenge: Longstr,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method attempts to authenticate, passing a block of SASL data for the security
/// mechanism at the server side.
ConnectionSecureOk {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionSecureOk {
/// must not be null
///
/// A block of opaque data passed to the security mechanism. The contents of this
/// data are defined by the SASL security mechanism.
response: Longstr,
},
pub response: Longstr,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method proposes a set of connection configuration values to the client. The
/// client can accept and/or adjust these.
ConnectionTune {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionTune {
/// Specifies highest channel number that the server permits. Usable channel numbers
/// are in the range 1..channel-max. Zero indicates no specified limit.
channel_max: Short,
pub channel_max: Short,
/// The largest frame size that the server proposes for the connection, including
/// frame header and end-byte. The client can negotiate a lower value. Zero means
/// that the server does not impose any specific limit but may reject very large
/// frames if it cannot allocate resources for them.
frame_max: Long,
pub frame_max: Long,
/// The delay, in seconds, of the connection heartbeat that the server wants.
/// Zero means the server does not want a heartbeat.
heartbeat: Short,
},
pub heartbeat: Short,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method sends the client's connection tuning parameters to the server.
/// Certain fields are negotiated, others provide capability information.
ConnectionTuneOk {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionTuneOk {
/// must not be null, must be less than the tune field of the method channel-max
///
/// The maximum total number of channels that the client will use per connection.
channel_max: Short,
pub channel_max: Short,
/// The largest frame size that the client and server will use for the connection.
/// Zero means that the client does not impose any specific limit but may reject
/// very large frames if it cannot allocate resources for them. Note that the
/// frame-max limit applies principally to content frames, where large contents can
/// be broken into frames of arbitrary size.
frame_max: Long,
pub frame_max: Long,
/// The delay, in seconds, of the connection heartbeat that the client wants. Zero
/// means the client does not want a heartbeat.
heartbeat: Short,
},
pub heartbeat: Short,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method opens a connection to a virtual host, which is a collection of
/// resources, and acts to separate multiple application domains within a server.
/// The server may apply arbitrary limits per virtual host, such as the number
/// of each type of entity that may be used, per connection and/or in total.
ConnectionOpen {
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionOpen {
/// The name of the virtual host to work with.
virtual_host: Path,
reserved_1: Shortstr,
reserved_2: Bit,
},
pub virtual_host: Path,
pub reserved_1: Shortstr,
pub reserved_2: Bit,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method signals to the client that the connection is ready for use.
ConnectionOpenOk { reserved_1: Shortstr },
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionOpenOk {
pub reserved_1: Shortstr,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method indicates that the sender wants to close the connection. This may be
/// due to internal conditions (e.g. a forced shut-down) or due to an error handling
/// a specific method, i.e. an exception. When a close is due to an exception, the
/// sender provides the class and method id of the method which caused the exception.
ConnectionClose {
reply_code: ReplyCode,
reply_text: ReplyText,
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionClose {
pub reply_code: ReplyCode,
pub reply_text: ReplyText,
/// When the close is provoked by a method exception, this is the class of the
/// method.
class_id: ClassId,
pub class_id: ClassId,
/// When the close is provoked by a method exception, this is the ID of the method.
method_id: MethodId,
},
pub method_id: MethodId,
}
/// The connection class provides methods for a client to establish a network connection to
/// a server, and for both peers to operate the connection thereafter.
/// This method confirms a Connection.Close method and tells the recipient that it is
/// safe to release resources for the connection and close the socket.
ConnectionCloseOk,
#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionCloseOk;
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// This method opens a channel to the server.
ChannelOpen { reserved_1: Shortstr },
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelOpen {
pub reserved_1: Shortstr,
}
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// This method signals to the client that the channel is ready for use.
ChannelOpenOk { reserved_1: Longstr },
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelOpenOk {
pub reserved_1: Longstr,
}
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// This method asks the peer to pause or restart the flow of content data sent by
@ -278,145 +363,165 @@ pub enum Method {
/// overflowing its queues or otherwise finding itself receiving more messages than
/// it can process. Note that this method is not intended for window control. It does
/// not affect contents returned by Basic.Get-Ok methods.
ChannelFlow {
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelFlow {
/// If 1, the peer starts sending content frames. If 0, the peer stops sending
/// content frames.
active: Bit,
},
pub active: Bit,
}
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// Confirms to the peer that a flow command was received and processed.
ChannelFlowOk {
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelFlowOk {
/// Confirms the setting of the processed flow method: 1 means the peer will start
/// sending or continue to send content frames; 0 means it will not.
active: Bit,
},
pub active: Bit,
}
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// This method indicates that the sender wants to close the channel. This may be due to
/// internal conditions (e.g. a forced shut-down) or due to an error handling a specific
/// method, i.e. an exception. When a close is due to an exception, the sender provides
/// the class and method id of the method which caused the exception.
ChannelClose {
reply_code: ReplyCode,
reply_text: ReplyText,
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelClose {
pub reply_code: ReplyCode,
pub reply_text: ReplyText,
/// When the close is provoked by a method exception, this is the class of the
/// method.
class_id: ClassId,
pub class_id: ClassId,
/// When the close is provoked by a method exception, this is the ID of the method.
method_id: MethodId,
},
pub method_id: MethodId,
}
/// The channel class provides methods for a client to establish a channel to a
/// server and for both peers to operate the channel thereafter.
/// This method confirms a Channel.Close method and tells the recipient that it is safe
/// to release resources for the channel.
ChannelCloseOk,
#[derive(Debug, Clone, PartialEq)]
pub struct ChannelCloseOk;
/// Exchanges match and distribute messages across queues. Exchanges can be configured in
/// the server or declared at runtime.
/// This method creates an exchange if it does not already exist, and if the exchange
/// exists, verifies that it is of the correct and expected class.
ExchangeDeclare {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct ExchangeDeclare {
pub reserved_1: Short,
/// must not be null
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Each exchange belongs to one of a set of exchange types implemented by the
/// server. The exchange types define the functionality of the exchange - i.e. how
/// messages are routed through it. It is not valid or meaningful to attempt to
/// change the type of an existing exchange.
r#type: Shortstr,
pub r#type: Shortstr,
/// If set, the server will reply with Declare-Ok if the exchange already
/// exists with the same name, and raise an error if not. The client can
/// use this to check whether an exchange exists without modifying the
/// server state. When set, all other method fields except name and no-wait
/// are ignored. A declare with both passive and no-wait has no effect.
/// Arguments are compared for semantic equivalence.
passive: Bit,
pub passive: Bit,
/// If set when creating a new exchange, the exchange will be marked as durable.
/// Durable exchanges remain active when a server restarts. Non-durable exchanges
/// (transient exchanges) are purged if/when a server restarts.
durable: Bit,
reserved_2: Bit,
reserved_3: Bit,
no_wait: NoWait,
pub durable: Bit,
pub reserved_2: Bit,
pub reserved_3: Bit,
pub no_wait: NoWait,
/// A set of arguments for the declaration. The syntax and semantics of these
/// arguments depends on the server implementation.
arguments: Table,
},
pub arguments: Table,
}
/// Exchanges match and distribute messages across queues. Exchanges can be configured in
/// the server or declared at runtime.
/// This method confirms a Declare method and confirms the name of the exchange,
/// essential for automatically-named exchanges.
ExchangeDeclareOk,
#[derive(Debug, Clone, PartialEq)]
pub struct ExchangeDeclareOk;
/// Exchanges match and distribute messages across queues. Exchanges can be configured in
/// the server or declared at runtime.
/// This method deletes an exchange. When an exchange is deleted all queue bindings on
/// the exchange are cancelled.
ExchangeDelete {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct ExchangeDelete {
pub reserved_1: Short,
/// must not be null
exchange: ExchangeName,
pub exchange: ExchangeName,
/// If set, the server will only delete the exchange if it has no queue bindings. If
/// the exchange has queue bindings the server does not delete it but raises a
/// channel exception instead.
if_unused: Bit,
no_wait: NoWait,
},
pub if_unused: Bit,
pub no_wait: NoWait,
}
/// Exchanges match and distribute messages across queues. Exchanges can be configured in
/// the server or declared at runtime.
/// This method confirms the deletion of an exchange.
ExchangeDeleteOk,
#[derive(Debug, Clone, PartialEq)]
pub struct ExchangeDeleteOk;
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method creates or checks a queue. When creating a new queue the client can
/// specify various properties that control the durability of the queue and its
/// contents, and the level of sharing for the queue.
QueueDeclare {
reserved_1: Short,
queue: QueueName,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueDeclare {
pub reserved_1: Short,
pub queue: QueueName,
/// If set, the server will reply with Declare-Ok if the queue already
/// exists with the same name, and raise an error if not. The client can
/// use this to check whether a queue exists without modifying the
/// server state. When set, all other method fields except name and no-wait
/// are ignored. A declare with both passive and no-wait has no effect.
/// Arguments are compared for semantic equivalence.
passive: Bit,
pub passive: Bit,
/// If set when creating a new queue, the queue will be marked as durable. Durable
/// queues remain active when a server restarts. Non-durable queues (transient
/// queues) are purged if/when a server restarts. Note that durable queues do not
/// necessarily hold persistent messages, although it does not make sense to send
/// persistent messages to a transient queue.
durable: Bit,
pub durable: Bit,
/// Exclusive queues may only be accessed by the current connection, and are
/// deleted when that connection closes. Passive declaration of an exclusive
/// queue by other connections are not allowed.
exclusive: Bit,
pub exclusive: Bit,
/// If set, the queue is deleted when all consumers have finished using it. The last
/// consumer can be cancelled either explicitly or because its channel is closed. If
/// there was no consumer ever on the queue, it won't be deleted. Applications can
/// explicitly delete auto-delete queues using the Delete method as normal.
auto_delete: Bit,
no_wait: NoWait,
pub auto_delete: Bit,
pub no_wait: NoWait,
/// A set of arguments for the declaration. The syntax and semantics of these
/// arguments depends on the server implementation.
arguments: Table,
},
pub arguments: Table,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method confirms a Declare method and confirms the name of the queue, essential
/// for automatically-named queues.
QueueDeclareOk {
#[derive(Debug, Clone, PartialEq)]
pub struct QueueDeclareOk {
/// must not be null
///
/// Reports the name of the queue. If the server generated a queue name, this field
/// contains that name.
queue: QueueName,
message_count: MessageCount,
pub queue: QueueName,
pub message_count: MessageCount,
/// Reports the number of active consumers for the queue. Note that consumers can
/// suspend activity (Channel.Flow) in which case they do not appear in this count.
consumer_count: Long,
},
pub consumer_count: Long,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
@ -424,11 +529,12 @@ pub enum Method {
/// receive any messages. In a classic messaging model, store-and-forward queues
/// are bound to a direct exchange and subscription queues are bound to a topic
/// exchange.
QueueBind {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueBind {
pub reserved_1: Short,
/// Specifies the name of the queue to bind.
queue: QueueName,
exchange: ExchangeName,
pub queue: QueueName,
pub exchange: ExchangeName,
/// Specifies the routing key for the binding. The routing key is used for routing
/// messages depending on the exchange configuration. Not all exchanges use a
/// routing key - refer to the specific exchange documentation. If the queue name
@ -437,89 +543,105 @@ pub enum Method {
/// key as well. If the queue name is provided but the routing key is empty, the
/// server does the binding with that empty routing key. The meaning of empty
/// routing keys depends on the exchange implementation.
routing_key: Shortstr,
no_wait: NoWait,
pub routing_key: Shortstr,
pub no_wait: NoWait,
/// A set of arguments for the binding. The syntax and semantics of these arguments
/// depends on the exchange class.
arguments: Table,
},
pub arguments: Table,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method confirms that the bind was successful.
QueueBindOk,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueBindOk;
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method unbinds a queue from an exchange.
QueueUnbind {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueUnbind {
pub reserved_1: Short,
/// Specifies the name of the queue to unbind.
queue: QueueName,
pub queue: QueueName,
/// The name of the exchange to unbind from.
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Specifies the routing key of the binding to unbind.
routing_key: Shortstr,
pub routing_key: Shortstr,
/// Specifies the arguments of the binding to unbind.
arguments: Table,
},
pub arguments: Table,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method confirms that the unbind was successful.
QueueUnbindOk,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueUnbindOk;
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method removes all messages from a queue which are not awaiting
/// acknowledgment.
QueuePurge {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct QueuePurge {
pub reserved_1: Short,
/// Specifies the name of the queue to purge.
queue: QueueName,
no_wait: NoWait,
},
pub queue: QueueName,
pub no_wait: NoWait,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method confirms the purge of a queue.
QueuePurgeOk {
#[derive(Debug, Clone, PartialEq)]
pub struct QueuePurgeOk {
/// Reports the number of messages purged.
message_count: MessageCount,
},
pub message_count: MessageCount,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method deletes a queue. When a queue is deleted any pending messages are sent
/// to a dead-letter queue if this is defined in the server configuration, and all
/// consumers on the queue are cancelled.
QueueDelete {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct QueueDelete {
pub reserved_1: Short,
/// Specifies the name of the queue to delete.
queue: QueueName,
pub queue: QueueName,
/// If set, the server will only delete the queue if it has no consumers. If the
/// queue has consumers the server does does not delete it but raises a channel
/// exception instead.
if_unused: Bit,
pub if_unused: Bit,
/// If set, the server will only delete the queue if it has no messages.
if_empty: Bit,
no_wait: NoWait,
},
pub if_empty: Bit,
pub no_wait: NoWait,
}
/// Queues store and forward messages. Queues can be configured in the server or created at
/// runtime. Queues must be attached to at least one exchange in order to receive messages
/// from publishers.
/// This method confirms the deletion of a queue.
QueueDeleteOk {
#[derive(Debug, Clone, PartialEq)]
pub struct QueueDeleteOk {
/// Reports the number of messages deleted.
message_count: MessageCount,
},
pub message_count: MessageCount,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method requests a specific quality of service. The QoS can be specified for the
/// current channel or for all channels on the connection. The particular properties and
/// semantics of a qos method always depend on the content class semantics. Though the
/// qos method could in principle apply to both peers, it is currently meaningful only
/// for the server.
BasicQos {
#[derive(Debug, Clone, PartialEq)]
pub struct BasicQos {
/// The client can request that messages be sent in advance so that when the client
/// finishes processing a message, the following message is already held locally,
/// rather than needing to be sent down the channel. Prefetching gives a performance
@ -528,187 +650,224 @@ pub enum Method {
/// available prefetch size (and also falls into other prefetch limits). May be set
/// to zero, meaning "no specific limit", although other prefetch limits may still
/// apply. The prefetch-size is ignored if the no-ack option is set.
prefetch_size: Long,
pub prefetch_size: Long,
/// Specifies a prefetch window in terms of whole messages. This field may be used
/// in combination with the prefetch-size field; a message will only be sent in
/// advance if both prefetch windows (and those at the channel and connection level)
/// allow it. The prefetch-count is ignored if the no-ack option is set.
prefetch_count: Short,
pub prefetch_count: Short,
/// By default the QoS settings apply to the current channel only. If this field is
/// set, they are applied to the entire connection.
global: Bit,
},
pub global: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method tells the client that the requested QoS levels could be handled by the
/// server. The requested QoS applies to all active consumers until a new QoS is
/// defined.
BasicQosOk,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicQosOk;
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method asks the server to start a "consumer", which is a transient request for
/// messages from a specific queue. Consumers last as long as the channel they were
/// declared on, or until the client cancels them.
BasicConsume {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicConsume {
pub reserved_1: Short,
/// Specifies the name of the queue to consume from.
queue: QueueName,
pub queue: QueueName,
/// Specifies the identifier for the consumer. The consumer tag is local to a
/// channel, so two clients can use the same consumer tags. If this field is
/// empty the server will generate a unique tag.
consumer_tag: ConsumerTag,
no_local: NoLocal,
no_ack: NoAck,
pub consumer_tag: ConsumerTag,
pub no_local: NoLocal,
pub no_ack: NoAck,
/// Request exclusive consumer access, meaning only this consumer can access the
/// queue.
exclusive: Bit,
no_wait: NoWait,
pub exclusive: Bit,
pub no_wait: NoWait,
/// A set of arguments for the consume. The syntax and semantics of these
/// arguments depends on the server implementation.
arguments: Table,
},
pub arguments: Table,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// The server provides the client with a consumer tag, which is used by the client
/// for methods called on the consumer at a later stage.
BasicConsumeOk {
#[derive(Debug, Clone, PartialEq)]
pub struct BasicConsumeOk {
/// Holds the consumer tag specified by the client or provided by the server.
consumer_tag: ConsumerTag,
},
pub consumer_tag: ConsumerTag,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method cancels a consumer. This does not affect already delivered
/// messages, but it does mean the server will not send any more messages for
/// that consumer. The client may receive an arbitrary number of messages in
/// between sending the cancel method and receiving the cancel-ok reply.
BasicCancel {
consumer_tag: ConsumerTag,
no_wait: NoWait,
},
#[derive(Debug, Clone, PartialEq)]
pub struct BasicCancel {
pub consumer_tag: ConsumerTag,
pub no_wait: NoWait,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method confirms that the cancellation was completed.
BasicCancelOk { consumer_tag: ConsumerTag },
#[derive(Debug, Clone, PartialEq)]
pub struct BasicCancelOk {
pub consumer_tag: ConsumerTag,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method publishes a message to a specific exchange. The message will be routed
/// to queues as defined by the exchange configuration and distributed to any active
/// consumers when the transaction, if any, is committed.
BasicPublish {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicPublish {
pub reserved_1: Short,
/// Specifies the name of the exchange to publish to. The exchange name can be
/// empty, meaning the default exchange. If the exchange name is specified, and that
/// exchange does not exist, the server will raise a channel exception.
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Specifies the routing key for the message. The routing key is used for routing
/// messages depending on the exchange configuration.
routing_key: Shortstr,
pub routing_key: Shortstr,
/// This flag tells the server how to react if the message cannot be routed to a
/// queue. If this flag is set, the server will return an unroutable message with a
/// Return method. If this flag is zero, the server silently drops the message.
mandatory: Bit,
pub mandatory: Bit,
/// This flag tells the server how to react if the message cannot be routed to a
/// queue consumer immediately. If this flag is set, the server will return an
/// undeliverable message with a Return method. If this flag is zero, the server
/// will queue the message, but with no guarantee that it will ever be consumed.
immediate: Bit,
},
pub immediate: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method returns an undeliverable message that was published with the "immediate"
/// flag set, or an unroutable message published with the "mandatory" flag set. The
/// reply code and text provide information about the reason that the message was
/// undeliverable.
BasicReturn {
reply_code: ReplyCode,
reply_text: ReplyText,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicReturn {
pub reply_code: ReplyCode,
pub reply_text: ReplyText,
/// Specifies the name of the exchange that the message was originally published
/// to. May be empty, meaning the default exchange.
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Specifies the routing key name specified when the message was published.
routing_key: Shortstr,
},
pub routing_key: Shortstr,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method delivers a message to the client, via a consumer. In the asynchronous
/// message delivery model, the client starts a consumer using the Consume method, then
/// the server responds with Deliver methods as and when messages arrive for that
/// consumer.
BasicDeliver {
consumer_tag: ConsumerTag,
delivery_tag: DeliveryTag,
redelivered: Redelivered,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicDeliver {
pub consumer_tag: ConsumerTag,
pub delivery_tag: DeliveryTag,
pub redelivered: Redelivered,
/// Specifies the name of the exchange that the message was originally published to.
/// May be empty, indicating the default exchange.
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Specifies the routing key name specified when the message was published.
routing_key: Shortstr,
},
pub routing_key: Shortstr,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method provides a direct access to the messages in a queue using a synchronous
/// dialogue that is designed for specific types of application where synchronous
/// functionality is more important than performance.
BasicGet {
reserved_1: Short,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicGet {
pub reserved_1: Short,
/// Specifies the name of the queue to get a message from.
queue: QueueName,
no_ack: NoAck,
},
pub queue: QueueName,
pub no_ack: NoAck,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method delivers a message to the client following a get method. A message
/// delivered by 'get-ok' must be acknowledged unless the no-ack option was set in the
/// get method.
BasicGetOk {
delivery_tag: DeliveryTag,
redelivered: Redelivered,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicGetOk {
pub delivery_tag: DeliveryTag,
pub redelivered: Redelivered,
/// Specifies the name of the exchange that the message was originally published to.
/// If empty, the message was published to the default exchange.
exchange: ExchangeName,
pub exchange: ExchangeName,
/// Specifies the routing key name specified when the message was published.
routing_key: Shortstr,
message_count: MessageCount,
},
pub routing_key: Shortstr,
pub message_count: MessageCount,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method tells the client that the queue has no messages available for the
/// client.
BasicGetEmpty { reserved_1: Shortstr },
#[derive(Debug, Clone, PartialEq)]
pub struct BasicGetEmpty {
pub reserved_1: Shortstr,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method acknowledges one or more messages delivered via the Deliver or Get-Ok
/// methods. The client can ask to confirm a single message or a set of messages up to
/// and including a specific message.
BasicAck {
delivery_tag: DeliveryTag,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicAck {
pub delivery_tag: DeliveryTag,
/// If set to 1, the delivery tag is treated as "up to and including", so that the
/// client can acknowledge multiple messages with a single method. If set to zero,
/// the delivery tag refers to a single message. If the multiple field is 1, and the
/// delivery tag is zero, tells the server to acknowledge all outstanding messages.
multiple: Bit,
},
pub multiple: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method allows a client to reject a message. It can be used to interrupt and
/// cancel large incoming messages, or return untreatable messages to their original
/// queue.
BasicReject {
delivery_tag: DeliveryTag,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicReject {
pub delivery_tag: DeliveryTag,
/// If requeue is true, the server will attempt to requeue the message. If requeue
/// is false or the requeue attempt fails the messages are discarded or dead-lettered.
requeue: Bit,
},
pub requeue: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method asks the server to redeliver all unacknowledged messages on a
/// specified channel. Zero or more messages may be redelivered. This method
/// is deprecated in favour of the synchronous Recover/Recover-Ok.
BasicRecoverAsync {
#[derive(Debug, Clone, PartialEq)]
pub struct BasicRecoverAsync {
/// If this field is zero, the message will be redelivered to the original
/// recipient. If this bit is 1, the server will attempt to requeue the message,
/// potentially then delivering it to an alternative subscriber.
requeue: Bit,
},
pub requeue: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method asks the server to redeliver all unacknowledged messages on a
/// specified channel. Zero or more messages may be redelivered. This method
/// replaces the asynchronous Recover.
BasicRecover {
#[derive(Debug, Clone, PartialEq)]
pub struct BasicRecover {
/// If this field is zero, the message will be redelivered to the original
/// recipient. If this bit is 1, the server will attempt to requeue the message,
/// potentially then delivering it to an alternative subscriber.
requeue: Bit,
},
pub requeue: Bit,
}
/// The Basic class provides methods that support an industry-standard messaging model.
/// This method acknowledges a Basic.Recover method.
BasicRecoverOk,
#[derive(Debug, Clone, PartialEq)]
pub struct BasicRecoverOk;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -720,7 +879,9 @@ pub enum Method {
/// mandatory flags on Basic.Publish methods is not defined.
/// This method sets the channel to use standard transactions. The client must use this
/// method at least once on a channel before using the Commit or Rollback methods.
TxSelect,
#[derive(Debug, Clone, PartialEq)]
pub struct TxSelect;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -732,7 +893,9 @@ pub enum Method {
/// mandatory flags on Basic.Publish methods is not defined.
/// This method confirms to the client that the channel was successfully set to use
/// standard transactions.
TxSelectOk,
#[derive(Debug, Clone, PartialEq)]
pub struct TxSelectOk;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -744,7 +907,9 @@ pub enum Method {
/// mandatory flags on Basic.Publish methods is not defined.
/// This method commits all message publications and acknowledgments performed in
/// the current transaction. A new transaction starts immediately after a commit.
TxCommit,
#[derive(Debug, Clone, PartialEq)]
pub struct TxCommit;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -756,7 +921,9 @@ pub enum Method {
/// mandatory flags on Basic.Publish methods is not defined.
/// This method confirms to the client that the commit succeeded. Note that if a commit
/// fails, the server raises a channel exception.
TxCommitOk,
#[derive(Debug, Clone, PartialEq)]
pub struct TxCommitOk;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -770,7 +937,9 @@ pub enum Method {
/// the current transaction. A new transaction starts immediately after a rollback.
/// Note that unacked messages will not be automatically redelivered by rollback;
/// if that is required an explicit recover call should be issued.
TxRollback,
#[derive(Debug, Clone, PartialEq)]
pub struct TxRollback;
/// The Tx class allows publish and ack operations to be batched into atomic
/// units of work. The intention is that all publish and ack requests issued
/// within a transaction will complete successfully or none of them will.
@ -782,5 +951,5 @@ pub enum Method {
/// mandatory flags on Basic.Publish methods is not defined.
/// This method confirms to the client that the rollback succeeded. Note that if an
/// rollback fails, the server raises a channel exception.
TxRollbackOk,
}
#[derive(Debug, Clone, PartialEq)]
pub struct TxRollbackOk;

11
amqp_messaging/src/methods/consume.rs
View file

@ -1,17 +1,10 @@
use amqp_core::connection::ChannelHandle;
use amqp_core::error::ProtocolError;
use amqp_core::methods::{Bit, ConsumerTag, NoAck, NoLocal, NoWait, QueueName, Table};
use amqp_core::methods::BasicConsume;
#[allow(clippy::too_many_arguments)]
pub async fn consume(
_channel_handle: ChannelHandle,
_queue: QueueName,
_consumer_tag: ConsumerTag,
_no_local: NoLocal,
_no_ack: NoAck,
_exclusive: Bit,
_no_wait: NoWait,
_arguments: Table,
_basic_consume: BasicConsume,
) -> Result<(), ProtocolError> {
Ok(())
}

93
amqp_messaging/src/methods/mod.rs
View file

@ -22,82 +22,23 @@ pub async fn handle_method(
info!(?method, "Handling method");
match method {
Method::ExchangeDeclare { .. } => amqp_todo!(),
Method::ExchangeDeclareOk => amqp_todo!(),
Method::ExchangeDelete { .. } => amqp_todo!(),
Method::ExchangeDeleteOk => amqp_todo!(),
Method::QueueDeclare {
queue,
passive,
durable,
exclusive,
auto_delete,
no_wait,
arguments,
..
} => {
queue::declare(
channel_handle,
queue,
passive,
durable,
exclusive,
auto_delete,
no_wait,
arguments,
)
.await
}
Method::ExchangeDeclare(_) => amqp_todo!(),
Method::ExchangeDeclareOk(_) => amqp_todo!(),
Method::ExchangeDelete(_) => amqp_todo!(),
Method::ExchangeDeleteOk(_) => amqp_todo!(),
Method::QueueDeclare(queue_declare) => queue::declare(channel_handle, queue_declare).await,
Method::QueueDeclareOk { .. } => amqp_todo!(),
Method::QueueBind {
queue,
exchange,
routing_key,
no_wait,
arguments,
..
} => {
queue::bind(
channel_handle,
queue,
exchange,
routing_key,
no_wait,
arguments,
)
.await
}
Method::QueueBindOk => amqp_todo!(),
Method::QueueBind(queue_bind) => queue::bind(channel_handle, queue_bind).await,
Method::QueueBindOk(_) => amqp_todo!(),
Method::QueueUnbind { .. } => amqp_todo!(),
Method::QueueUnbindOk => amqp_todo!(),
Method::QueueUnbindOk(_) => amqp_todo!(),
Method::QueuePurge { .. } => amqp_todo!(),
Method::QueuePurgeOk { .. } => amqp_todo!(),
Method::QueueDelete { .. } => amqp_todo!(),
Method::QueueDeleteOk { .. } => amqp_todo!(),
Method::BasicQos { .. } => amqp_todo!(),
Method::BasicQosOk => amqp_todo!(),
Method::BasicConsume {
queue,
consumer_tag,
no_local,
no_ack,
exclusive,
no_wait,
arguments,
..
} => {
consume::consume(
channel_handle,
queue,
consumer_tag,
no_local,
no_ack,
exclusive,
no_wait,
arguments,
)
.await
}
Method::BasicQosOk(_) => amqp_todo!(),
Method::BasicConsume(consume) => consume::consume(channel_handle, consume).await,
Method::BasicConsumeOk { .. } => amqp_todo!(),
Method::BasicCancel { .. } => amqp_todo!(),
Method::BasicCancelOk { .. } => amqp_todo!(),
@ -110,13 +51,13 @@ pub async fn handle_method(
Method::BasicReject { .. } => amqp_todo!(),
Method::BasicRecoverAsync { .. } => amqp_todo!(),
Method::BasicRecover { .. } => amqp_todo!(),
Method::BasicRecoverOk => amqp_todo!(),
Method::TxSelect
| Method::TxSelectOk
| Method::TxCommit
| Method::TxCommitOk
| Method::TxRollback
| Method::TxRollbackOk => amqp_todo!(),
Method::BasicRecoverOk(_) => amqp_todo!(),
Method::TxSelect(_)
| Method::TxSelectOk(_)
| Method::TxCommit(_)
| Method::TxCommitOk(_)
| Method::TxRollback(_)
| Method::TxRollbackOk(_) => amqp_todo!(),
Method::BasicPublish { .. } => {
unreachable!("Basic.Publish is handled somewhere else because it has a body")
}

28
amqp_messaging/src/methods/queue.rs
View file

@ -1,23 +1,27 @@
use amqp_core::connection::ChannelHandle;
use amqp_core::error::{ConException, ProtocolError};
use amqp_core::methods::{Bit, ExchangeName, NoWait, QueueName, Shortstr, Table};
use amqp_core::methods::{QueueBind, QueueDeclare};
use amqp_core::queue::{QueueDeletion, QueueId, RawQueue};
use amqp_core::{amqp_todo, GlobalData};
use parking_lot::Mutex;
use std::sync::atomic::AtomicUsize;
use std::sync::Arc;
#[allow(clippy::too_many_arguments)]
pub async fn declare(
channel_handle: ChannelHandle,
queue_name: QueueName,
passive: Bit,
durable: Bit,
exclusive: Bit,
auto_delete: Bit,
no_wait: NoWait,
arguments: Table,
queue_declare: QueueDeclare,
) -> Result<(), ProtocolError> {
let QueueDeclare {
queue: queue_name,
passive,
durable,
exclusive,
auto_delete,
no_wait,
arguments,
..
} = queue_declare;
if !arguments.is_empty() {
return Err(ConException::Todo.into());
}
@ -58,11 +62,7 @@ pub async fn declare(
pub async fn bind(
_channel_handle: ChannelHandle,
_queue: QueueName,
_exchange: ExchangeName,
_routing_key: Shortstr,
_no_wait: NoWait,
_arguments: Table,
_queue_bind: QueueBind,
) -> Result<(), ProtocolError> {
amqp_todo!();
}

52
amqp_transport/src/connection.rs
View file

@ -3,7 +3,11 @@ use crate::frame::{ContentHeader, Frame, FrameType};
use crate::{frame, methods, sasl};
use amqp_core::connection::{ChannelHandle, ChannelNum, ConnectionHandle, ConnectionId};
use amqp_core::message::{MessageId, RawMessage, RoutingInformation};
use amqp_core::methods::{FieldValue, Method, Table};
use amqp_core::methods::{
BasicPublish, ChannelClose, ChannelCloseOk, ChannelOpenOk, ConnectionClose, ConnectionCloseOk,
ConnectionOpen, ConnectionOpenOk, ConnectionStart, ConnectionStartOk, ConnectionTune,
ConnectionTuneOk, FieldValue, Method, Table,
};
use amqp_core::GlobalData;
use anyhow::Context;
use bytes::Bytes;
@ -134,7 +138,7 @@ impl Connection {
}
async fn start(&mut self) -> Result<()> {
let start_method = Method::ConnectionStart {
let start_method = Method::ConnectionStart(ConnectionStart {
version_major: 0,
version_minor: 9,
server_properties: server_properties(
@ -144,7 +148,7 @@ impl Connection {
),
mechanisms: "PLAIN".into(),
locales: "en_US".into(),
};
});
debug!(?start_method, "Sending Start method");
self.send_method(ChannelNum::zero(), start_method).await?;
@ -152,12 +156,12 @@ impl Connection {
let start_ok = self.recv_method().await?;
debug!(?start_ok, "Received Start-Ok");
if let Method::ConnectionStartOk {
if let Method::ConnectionStartOk(ConnectionStartOk {
mechanism,
locale,
response,
..
} = start_ok
}) = start_ok
{
ensure_conn(mechanism == "PLAIN")?;
ensure_conn(locale == "en_US")?;
@ -171,11 +175,11 @@ impl Connection {
}
async fn tune(&mut self) -> Result<()> {
let tune_method = Method::ConnectionTune {
let tune_method = Method::ConnectionTune(ConnectionTune {
channel_max: CHANNEL_MAX,
frame_max: FRAME_SIZE_MAX,
heartbeat: HEARTBEAT_DELAY,
};
});
debug!("Sending Tune method");
self.send_method(ChannelNum::zero(), tune_method).await?;
@ -183,11 +187,11 @@ impl Connection {
let tune_ok = self.recv_method().await?;
debug!(?tune_ok, "Received Tune-Ok method");
if let Method::ConnectionTuneOk {
if let Method::ConnectionTuneOk(ConnectionTuneOk {
channel_max,
frame_max,
heartbeat,
} = tune_ok
}) = tune_ok
{
self.channel_max = channel_max;
self.max_frame_size = usize::try_from(frame_max).unwrap();
@ -202,15 +206,15 @@ impl Connection {
let open = self.recv_method().await?;
debug!(?open, "Received Open method");
if let Method::ConnectionOpen { virtual_host, .. } = open {
if let Method::ConnectionOpen(ConnectionOpen { virtual_host, .. }) = open {
ensure_conn(virtual_host == "/")?;
}
self.send_method(
ChannelNum::zero(),
Method::ConnectionOpenOk {
Method::ConnectionOpenOk(ConnectionOpenOk {
reserved_1: "".to_string(),
},
}),
)
.await?;
@ -242,14 +246,17 @@ impl Connection {
.map(|channel| channel.status.take());
match method {
Method::ConnectionClose {
Method::ConnectionClose(ConnectionClose {
reply_code,
reply_text,
class_id,
method_id,
} => {
}) => {
info!(%reply_code, %reply_text, %class_id, %method_id, "Closing connection");
self.send_method(ChannelNum::zero(), Method::ConnectionCloseOk {})
self.send_method(
ChannelNum::zero(),
Method::ConnectionCloseOk(ConnectionCloseOk),
)
.await?;
return Err(ProtocolError::GracefulClose.into());
}
@ -344,13 +351,13 @@ impl Connection {
// The only method with content that is sent to the server is Basic.Publish.
ensure_conn(header.class_id == BASIC_CLASS_ID)?;
if let Method::BasicPublish {
if let Method::BasicPublish(BasicPublish {
exchange,
routing_key,
mandatory,
immediate,
..
} = method
}) = method
{
let message = RawMessage {
id: MessageId::random(),
@ -415,9 +422,9 @@ impl Connection {
self.send_method(
channel_num,
Method::ChannelOpenOk {
Method::ChannelOpenOk(ChannelOpenOk {
reserved_1: Vec::new(),
},
}),
)
.await?;
@ -425,17 +432,18 @@ impl Connection {
}
async fn channel_close(&mut self, channel_id: ChannelNum, method: Method) -> Result<()> {
if let Method::ChannelClose {
if let Method::ChannelClose(ChannelClose {
reply_code: code,
reply_text: reason,
..
} = method
}) = method
{
info!(%code, %reason, "Closing channel");
if let Some(channel) = self.channels.remove(&channel_id) {
drop(channel);
self.send_method(channel_id, Method::ChannelCloseOk).await?;
self.send_method(channel_id, Method::ChannelCloseOk(ChannelCloseOk))
.await?;
} else {
return Err(ConException::Todo.into());
}

514
amqp_transport/src/methods/generated.rs
View file

File diff suppressed because it is too large Load diff

10
amqp_transport/src/tests.rs
View file

@ -1,13 +1,13 @@
use crate::frame::FrameType;
use crate::{frame, methods};
use amqp_core::connection::ChannelNum;
use amqp_core::methods::{FieldValue, Method};
use amqp_core::methods::{ConnectionStart, ConnectionStartOk, FieldValue, Method};
use std::collections::HashMap;
#[tokio::test]
async fn write_start_ok_frame() {
let mut payload = Vec::new();
let method = Method::ConnectionStart {
let method = Method::ConnectionStart(ConnectionStart {
version_major: 0,
version_minor: 9,
server_properties: HashMap::from([(
@ -16,7 +16,7 @@ async fn write_start_ok_frame() {
)]),
mechanisms: "PLAIN".into(),
locales: "en_US".into(),
};
});
methods::write::write_method(method, &mut payload).unwrap();
@ -141,7 +141,7 @@ fn read_start_ok_payload() {
assert_eq!(
method,
Method::ConnectionStartOk {
Method::ConnectionStartOk(ConnectionStartOk {
client_properties: HashMap::from([
(
"product".to_string(),
@ -179,6 +179,6 @@ fn read_start_ok_payload() {
mechanism: "PLAIN".to_string(),
response: "\x00admin\x00".into(),
locale: "en_US".to_string()
}
})
);
}

40
xtask/src/codegen/mod.rs
View file

@ -211,11 +211,31 @@ impl Codegen {
for class in &amqp.classes {
let enum_name = class.name.to_upper_camel_case();
for method in &class.methods {
let method_name = method.name.to_upper_camel_case();
write!(
self.output,
" {enum_name}{method_name}({enum_name}{method_name}),"
)
.ok();
}
}
writeln!(self.output, "}}\n").ok();
// now codegen the individual structs
for class in &amqp.classes {
let class_name = class.name.to_upper_camel_case();
for method in &class.methods {
let method_name = method.name.to_upper_camel_case();
self.doc_comment(&class.doc, 4);
self.doc_comment(&method.doc, 4);
write!(self.output, " {enum_name}{method_name}").ok();
writeln!(
self.output,
"#[derive(Debug, Clone, PartialEq)]
pub struct {class_name}{method_name}"
)
.ok();
if !method.fields.is_empty() {
writeln!(self.output, " {{").ok();
for field in &method.fields {
@ -228,21 +248,19 @@ impl Codegen {
writeln!(self.output, " /// {field_docs}").ok();
if !field.doc.is_empty() {
writeln!(self.output, " ///").ok();
self.doc_comment(&field.doc, 8);
self.doc_comment(&field.doc, 4);
}
} else {
self.doc_comment(&field.doc, 8);
self.doc_comment(&field.doc, 4);
}
writeln!(self.output, " {field_name}: {field_type},").ok();
writeln!(self.output, " pub {field_name}: {field_type},").ok();
}
writeln!(self.output, " }},").ok();
} else {
writeln!(self.output, ",").ok();
}
}
}
writeln!(self.output, " }}\n").ok();
} else {
writeln!(self.output, ";\n").ok();
}
}
}
}
fn amqp_type_to_rust_type(&self, amqp_type: &str) -> &'static str {

4
xtask/src/codegen/parser.rs
View file

@ -154,14 +154,14 @@ pub type IResult<'a, T> = nom::IResult<&'a [u8], T, TransError>;
let method_name = method.name.to_upper_camel_case();
writeln!(
self.output,
" Ok((input, Method::{class_name}{method_name} {{"
" Ok((input, Method::{class_name}{method_name}({class_name}{method_name} {{"
)
.ok();
for field in &method.fields {
let field_name = self.snake_case(&field.name);
writeln!(self.output, " {field_name},").ok();
}
writeln!(self.output, " }}))").ok();
writeln!(self.output, " }})))").ok();
writeln!(self.output, "}}").ok();
}

4
xtask/src/codegen/random.rs
View file

@ -43,7 +43,7 @@ use crate::methods::RandomMethod;
let method_name = method.name.to_upper_camel_case();
writeln!(
self.output,
" {i} => Method::{class_name}{method_name} {{"
" {i} => Method::{class_name}{method_name}( {class_name}{method_name}{{"
)
.ok();
for field in &method.fields {
@ -54,7 +54,7 @@ use crate::methods::RandomMethod;
)
.ok();
}
writeln!(self.output, " }},").ok();
writeln!(self.output, " }}),").ok();
}
writeln!(
self.output,

8
xtask/src/codegen/write.rs
View file

@ -22,12 +22,16 @@ pub fn write_method<W: Write>(method: Method, mut writer: W) -> Result<(), Trans
for method in &class.methods {
let method_name = method.name.to_upper_camel_case();
let method_index = method.index;
writeln!(self.output, " Method::{class_name}{method_name} {{").ok();
writeln!(
self.output,
" Method::{class_name}{method_name}({class_name}{method_name} {{"
)
.ok();
for field in &method.fields {
let field_name = self.snake_case(&field.name);
writeln!(self.output, " {field_name},").ok();
}
writeln!(self.output, " }} => {{").ok();
writeln!(self.output, " }}) => {{").ok();
let [ci0, ci1] = class_index.to_be_bytes();
let [mi0, mi1] = method_index.to_be_bytes();
writeln!(