diff --git a/amqp_core/src/methods/generated.rs b/amqp_core/src/methods/generated.rs index bc4f27f..04e808a 100644 --- a/amqp_core/src/methods/generated.rs +++ b/amqp_core/src/methods/generated.rs @@ -126,661 +126,830 @@ pub type Table = super::Table; #[derive(Debug, Clone, PartialEq)] pub enum Method { - /// 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 { - /// The major version number can take any value from 0 to 99 as defined in the - /// AMQP specification. - 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, - /// must not be null - /// - /// A list of the security mechanisms that the server supports, delimited by spaces. - 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, - }, - /// 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, - /// must not be null - /// - /// A single security mechanisms selected by the client, which must be one of those - /// specified by the server. - 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, - /// must not be null - /// - /// A single message locale selected by the client, which must be one of those - /// specified by the server. - 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 { - /// Challenge information, a block of opaque binary data passed to the security - /// mechanism. - 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 { - /// 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, - }, - /// 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 { - /// 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, - /// 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, - /// The delay, in seconds, of the connection heartbeat that the server wants. - /// Zero means the server does not want a heartbeat. - 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 { - /// 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, - /// 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, - /// The delay, in seconds, of the connection heartbeat that the client wants. Zero - /// means the client does not want a heartbeat. - 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 { - /// The name of the virtual host to work with. - virtual_host: Path, - reserved_1: Shortstr, - 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 }, - /// 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, - /// When the close is provoked by a method exception, this is the class of the - /// method. - class_id: ClassId, - /// When the close is provoked by a method exception, this is the ID of the method. - 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, - /// 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 }, - /// 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 }, - /// 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 - /// a consumer. This is a simple flow-control mechanism that a peer can use to avoid - /// 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 { - /// If 1, the peer starts sending content frames. If 0, the peer stops sending - /// content frames. - 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 { - /// 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, - }, - /// 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, - /// When the close is provoked by a method exception, this is the class of the - /// method. - class_id: ClassId, - /// When the close is provoked by a method exception, this is the ID of the method. - 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, - /// 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, - /// must not be null - 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, - /// 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, - /// 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, - /// A set of arguments for the declaration. The syntax and semantics of these - /// arguments depends on the server implementation. - 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, - /// 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, - /// must not be null - 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, - }, - /// 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, - /// 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, - /// 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, - /// 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, - /// 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, - /// 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, - /// A set of arguments for the declaration. The syntax and semantics of these - /// arguments depends on the server implementation. - 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 { - /// 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, - /// 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, - }, - /// 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 binds a queue to an exchange. Until a queue is bound it will not - /// 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, - /// Specifies the name of the queue to bind. - queue: QueueName, - 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 - /// is empty, the server uses the last queue declared on the channel. If the - /// routing key is also empty, the server uses this queue name for the routing - /// 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, - /// A set of arguments for the binding. The syntax and semantics of these arguments - /// depends on the exchange class. - 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, - /// 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, - /// Specifies the name of the queue to unbind. - queue: QueueName, - /// The name of the exchange to unbind from. - exchange: ExchangeName, - /// Specifies the routing key of the binding to unbind. - routing_key: Shortstr, - /// Specifies the arguments of the binding to unbind. - 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, - /// 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, - /// Specifies the name of the queue to purge. - queue: QueueName, - 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 { - /// Reports the number of messages purged. - 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, - /// Specifies the name of the queue to delete. - 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, - /// If set, the server will only delete the queue if it has no messages. - if_empty: Bit, - 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 { - /// Reports the number of messages deleted. - 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 { - /// 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 - /// improvement. This field specifies the prefetch window size in octets. The server - /// will send a message in advance if it is equal to or smaller in size than the - /// 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, - /// 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, - /// 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, - }, - /// 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, - /// 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, - /// Specifies the name of the queue to consume from. - 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, - /// Request exclusive consumer access, meaning only this consumer can access the - /// queue. - exclusive: Bit, - no_wait: NoWait, - /// A set of arguments for the consume. The syntax and semantics of these - /// arguments depends on the server implementation. - 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 { - /// Holds the consumer tag specified by the client or provided by the server. - 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, - }, - /// The Basic class provides methods that support an industry-standard messaging model. - /// This method confirms that the cancellation was completed. - BasicCancelOk { 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, - /// 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, - /// Specifies the routing key for the message. The routing key is used for routing - /// messages depending on the exchange configuration. - 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, - /// 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, - }, - /// 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, - /// Specifies the name of the exchange that the message was originally published - /// to. May be empty, meaning the default exchange. - exchange: ExchangeName, - /// Specifies the routing key name specified when the message was published. - 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, - /// Specifies the name of the exchange that the message was originally published to. - /// May be empty, indicating the default exchange. - exchange: ExchangeName, - /// Specifies the routing key name specified when the message was published. - 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, - /// Specifies the name of the queue to get a message from. - queue: QueueName, - 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, - /// 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, - /// Specifies the routing key name specified when the message was published. - routing_key: Shortstr, - 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 }, - /// 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, - /// 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, - }, - /// 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, - /// 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, - }, - /// 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 { - /// 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, - }, - /// 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 { - /// 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, - }, - /// The Basic class provides methods that support an industry-standard messaging model. - /// This method acknowledges a Basic.Recover method. - 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// 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, - /// 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// 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, - /// 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// 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, - /// 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// 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, - /// 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// mandatory flags on Basic.Publish methods is not defined. - /// This method abandons all message publications and acknowledgments performed in - /// 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, - /// 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. - /// Servers SHOULD implement atomic transactions at least where all publish - /// or ack requests affect a single queue. Transactions that cover multiple - /// queues may be non-atomic, given that queues can be created and destroyed - /// asynchronously, and such events do not form part of any transaction. - /// Further, the behaviour of transactions with respect to the immediate and - /// 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, + 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. +#[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. + pub version_major: Octet, + /// The minor version number can take any value from 0 to 99 as defined in the + /// AMQP specification. + 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. + 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. + 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. +#[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. + 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. + 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. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct ConnectionSecure { + /// Challenge information, a block of opaque binary data passed to the security + /// mechanism. + 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. +#[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. + 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. +#[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. + 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. + 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. + 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. +#[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. + 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. + 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. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct ConnectionOpen { + /// The name of the virtual host to work with. + 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. +#[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. +#[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. + pub class_id: ClassId, + /// When the close is provoked by a method exception, this is the ID of the method. + 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. +#[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. +#[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. +#[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 +/// a consumer. This is a simple flow-control mechanism that a peer can use to avoid +/// 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. +#[derive(Debug, Clone, PartialEq)] +pub struct ChannelFlow { + /// If 1, the peer starts sending content frames. If 0, the peer stops sending + /// content frames. + 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. +#[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. + 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. +#[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. + pub class_id: ClassId, + /// When the close is provoked by a method exception, this is the ID of the method. + 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. +#[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. +#[derive(Debug, Clone, PartialEq)] +pub struct ExchangeDeclare { + pub reserved_1: Short, + /// must not be null + 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. + 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. + 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. + 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. + 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. +#[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. +#[derive(Debug, Clone, PartialEq)] +pub struct ExchangeDelete { + pub reserved_1: Short, + /// must not be null + 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. + 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. +#[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. +#[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. + 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. + 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. + 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. + 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. + 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. +#[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. + 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. + 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. +/// This method binds a queue to an exchange. Until a queue is bound it will not +/// 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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueueBind { + pub reserved_1: Short, + /// Specifies the name of the queue to bind. + 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 + /// is empty, the server uses the last queue declared on the channel. If the + /// routing key is also empty, the server uses this queue name for the routing + /// 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. + 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. + 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. +#[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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueueUnbind { + pub reserved_1: Short, + /// Specifies the name of the queue to unbind. + pub queue: QueueName, + /// The name of the exchange to unbind from. + pub exchange: ExchangeName, + /// Specifies the routing key of the binding to unbind. + pub routing_key: Shortstr, + /// Specifies the arguments of the binding to unbind. + 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. +#[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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueuePurge { + pub reserved_1: Short, + /// Specifies the name of the queue to purge. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueuePurgeOk { + /// Reports the number of messages purged. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueueDelete { + pub reserved_1: Short, + /// Specifies the name of the queue to delete. + 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. + pub if_unused: Bit, + /// If set, the server will only delete the queue if it has no messages. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct QueueDeleteOk { + /// Reports the number of messages deleted. + 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. +#[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 + /// improvement. This field specifies the prefetch window size in octets. The server + /// will send a message in advance if it is equal to or smaller in size than the + /// 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. + 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. + 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. + 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. +#[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. +#[derive(Debug, Clone, PartialEq)] +pub struct BasicConsume { + pub reserved_1: Short, + /// Specifies the name of the queue to consume from. + 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. + pub consumer_tag: ConsumerTag, + pub no_local: NoLocal, + pub no_ack: NoAck, + /// Request exclusive consumer access, meaning only this consumer can access the + /// queue. + 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. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct BasicConsumeOk { + /// Holds the consumer tag specified by the client or provided by the server. + 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. +#[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. +#[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. +#[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. + pub exchange: ExchangeName, + /// Specifies the routing key for the message. The routing key is used for routing + /// messages depending on the exchange configuration. + 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. + 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. + 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. +#[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. + pub exchange: ExchangeName, + /// Specifies the routing key name specified when the message was published. + 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. +#[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. + pub exchange: ExchangeName, + /// Specifies the routing key name specified when the message was published. + 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. +#[derive(Debug, Clone, PartialEq)] +pub struct BasicGet { + pub reserved_1: Short, + /// Specifies the name of the queue to get a message from. + 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. +#[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. + pub exchange: ExchangeName, + /// Specifies the routing key name specified when the message was published. + 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. +#[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. +#[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. + 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. +#[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. + 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. +#[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. + 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. +#[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. + pub requeue: Bit, +} + +/// The Basic class provides methods that support an industry-standard messaging model. +/// This method acknowledges a Basic.Recover method. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// 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. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// 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. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// 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. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// 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. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// mandatory flags on Basic.Publish methods is not defined. +/// This method abandons all message publications and acknowledgments performed in +/// 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. +#[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. +/// Servers SHOULD implement atomic transactions at least where all publish +/// or ack requests affect a single queue. Transactions that cover multiple +/// queues may be non-atomic, given that queues can be created and destroyed +/// asynchronously, and such events do not form part of any transaction. +/// Further, the behaviour of transactions with respect to the immediate and +/// 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. +#[derive(Debug, Clone, PartialEq)] +pub struct TxRollbackOk; diff --git a/amqp_messaging/src/methods/consume.rs b/amqp_messaging/src/methods/consume.rs index c5cd341..f2f0fc5 100644 --- a/amqp_messaging/src/methods/consume.rs +++ b/amqp_messaging/src/methods/consume.rs @@ -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(()) } diff --git a/amqp_messaging/src/methods/mod.rs b/amqp_messaging/src/methods/mod.rs index 478b23a..08c8b2e 100644 --- a/amqp_messaging/src/methods/mod.rs +++ b/amqp_messaging/src/methods/mod.rs @@ -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") } diff --git a/amqp_messaging/src/methods/queue.rs b/amqp_messaging/src/methods/queue.rs index fb7406f..0ca0f0d 100644 --- a/amqp_messaging/src/methods/queue.rs +++ b/amqp_messaging/src/methods/queue.rs @@ -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!(); } diff --git a/amqp_transport/src/connection.rs b/amqp_transport/src/connection.rs index c485b5d..874bdec 100644 --- a/amqp_transport/src/connection.rs +++ b/amqp_transport/src/connection.rs @@ -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,15 +246,18 @@ 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 {}) - .await?; + self.send_method( + ChannelNum::zero(), + Method::ConnectionCloseOk(ConnectionCloseOk), + ) + .await?; return Err(ProtocolError::GracefulClose.into()); } Method::ChannelOpen { .. } => self.channel_open(frame.channel).await?, @@ -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()); } diff --git a/amqp_transport/src/methods/generated.rs b/amqp_transport/src/methods/generated.rs index 789ecfe..7274a53 100644 --- a/amqp_transport/src/methods/generated.rs +++ b/amqp_transport/src/methods/generated.rs @@ -135,13 +135,13 @@ pub mod parse { } Ok(( input, - Method::ConnectionStart { + Method::ConnectionStart(ConnectionStart { version_major, version_minor, server_properties, mechanisms, locales, - }, + }), )) } fn connection_start_ok(input: &[u8]) -> IResult<'_, Method> { @@ -165,19 +165,22 @@ pub mod parse { } Ok(( input, - Method::ConnectionStartOk { + Method::ConnectionStartOk(ConnectionStartOk { client_properties, mechanism, response, locale, - }, + }), )) } fn connection_secure(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; let (input, challenge) = domain_longstr(input).map_err(fail_err("field challenge in method secure"))?; - Ok((input, Method::ConnectionSecure { challenge })) + Ok(( + input, + Method::ConnectionSecure(ConnectionSecure { challenge }), + )) } fn connection_secure_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; @@ -186,7 +189,10 @@ pub mod parse { if response.is_empty() { fail!("string was null for field response") } - Ok((input, Method::ConnectionSecureOk { response })) + Ok(( + input, + Method::ConnectionSecureOk(ConnectionSecureOk { response }), + )) } fn connection_tune(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(30_u16.to_be_bytes())(input)?; @@ -198,11 +204,11 @@ pub mod parse { domain_short(input).map_err(fail_err("field heartbeat in method tune"))?; Ok(( input, - Method::ConnectionTune { + Method::ConnectionTune(ConnectionTune { channel_max, frame_max, heartbeat, - }, + }), )) } fn connection_tune_ok(input: &[u8]) -> IResult<'_, Method> { @@ -215,11 +221,11 @@ pub mod parse { domain_short(input).map_err(fail_err("field heartbeat in method tune-ok"))?; Ok(( input, - Method::ConnectionTuneOk { + Method::ConnectionTuneOk(ConnectionTuneOk { channel_max, frame_max, heartbeat, - }, + }), )) } fn connection_open(input: &[u8]) -> IResult<'_, Method> { @@ -232,18 +238,21 @@ pub mod parse { let reserved_2 = bits[0]; Ok(( input, - Method::ConnectionOpen { + Method::ConnectionOpen(ConnectionOpen { virtual_host, reserved_1, reserved_2, - }, + }), )) } fn connection_open_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(41_u16.to_be_bytes())(input)?; let (input, reserved_1) = domain_shortstr(input).map_err(fail_err("field reserved-1 in method open-ok"))?; - Ok((input, Method::ConnectionOpenOk { reserved_1 })) + Ok(( + input, + Method::ConnectionOpenOk(ConnectionOpenOk { reserved_1 }), + )) } fn connection_close(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(50_u16.to_be_bytes())(input)?; @@ -257,17 +266,17 @@ pub mod parse { domain_method_id(input).map_err(fail_err("field method-id in method close"))?; Ok(( input, - Method::ConnectionClose { + Method::ConnectionClose(ConnectionClose { reply_code, reply_text, class_id, method_id, - }, + }), )) } fn connection_close_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(51_u16.to_be_bytes())(input)?; - Ok((input, Method::ConnectionCloseOk {})) + Ok((input, Method::ConnectionCloseOk(ConnectionCloseOk {}))) } fn channel(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; @@ -285,25 +294,25 @@ pub mod parse { let (input, _) = tag(10_u16.to_be_bytes())(input)?; let (input, reserved_1) = domain_shortstr(input).map_err(fail_err("field reserved-1 in method open"))?; - Ok((input, Method::ChannelOpen { reserved_1 })) + Ok((input, Method::ChannelOpen(ChannelOpen { reserved_1 }))) } fn channel_open_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(11_u16.to_be_bytes())(input)?; let (input, reserved_1) = domain_longstr(input).map_err(fail_err("field reserved-1 in method open-ok"))?; - Ok((input, Method::ChannelOpenOk { reserved_1 })) + Ok((input, Method::ChannelOpenOk(ChannelOpenOk { reserved_1 }))) } fn channel_flow(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; let (input, bits) = bit(input, 1).map_err(fail_err("field active in method flow"))?; let active = bits[0]; - Ok((input, Method::ChannelFlow { active })) + Ok((input, Method::ChannelFlow(ChannelFlow { active }))) } fn channel_flow_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; let (input, bits) = bit(input, 1).map_err(fail_err("field active in method flow-ok"))?; let active = bits[0]; - Ok((input, Method::ChannelFlowOk { active })) + Ok((input, Method::ChannelFlowOk(ChannelFlowOk { active }))) } fn channel_close(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(40_u16.to_be_bytes())(input)?; @@ -317,17 +326,17 @@ pub mod parse { domain_method_id(input).map_err(fail_err("field method-id in method close"))?; Ok(( input, - Method::ChannelClose { + Method::ChannelClose(ChannelClose { reply_code, reply_text, class_id, method_id, - }, + }), )) } fn channel_close_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(41_u16.to_be_bytes())(input)?; - Ok((input, Method::ChannelCloseOk {})) + Ok((input, Method::ChannelCloseOk(ChannelCloseOk {}))) } fn exchange(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(40_u16.to_be_bytes())(input)?; @@ -360,7 +369,7 @@ pub mod parse { domain_table(input).map_err(fail_err("field arguments in method declare"))?; Ok(( input, - Method::ExchangeDeclare { + Method::ExchangeDeclare(ExchangeDeclare { reserved_1, exchange, r#type, @@ -370,12 +379,12 @@ pub mod parse { reserved_3, no_wait, arguments, - }, + }), )) } fn exchange_declare_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(11_u16.to_be_bytes())(input)?; - Ok((input, Method::ExchangeDeclareOk {})) + Ok((input, Method::ExchangeDeclareOk(ExchangeDeclareOk {}))) } fn exchange_delete(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; @@ -391,17 +400,17 @@ pub mod parse { let no_wait = bits[1]; Ok(( input, - Method::ExchangeDelete { + Method::ExchangeDelete(ExchangeDelete { reserved_1, exchange, if_unused, no_wait, - }, + }), )) } fn exchange_delete_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; - Ok((input, Method::ExchangeDeleteOk {})) + Ok((input, Method::ExchangeDeleteOk(ExchangeDeleteOk {}))) } fn queue(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(50_u16.to_be_bytes())(input)?; @@ -435,7 +444,7 @@ pub mod parse { domain_table(input).map_err(fail_err("field arguments in method declare"))?; Ok(( input, - Method::QueueDeclare { + Method::QueueDeclare(QueueDeclare { reserved_1, queue, passive, @@ -444,7 +453,7 @@ pub mod parse { auto_delete, no_wait, arguments, - }, + }), )) } fn queue_declare_ok(input: &[u8]) -> IResult<'_, Method> { @@ -460,11 +469,11 @@ pub mod parse { domain_long(input).map_err(fail_err("field consumer-count in method declare-ok"))?; Ok(( input, - Method::QueueDeclareOk { + Method::QueueDeclareOk(QueueDeclareOk { queue, message_count, consumer_count, - }, + }), )) } fn queue_bind(input: &[u8]) -> IResult<'_, Method> { @@ -483,19 +492,19 @@ pub mod parse { domain_table(input).map_err(fail_err("field arguments in method bind"))?; Ok(( input, - Method::QueueBind { + Method::QueueBind(QueueBind { reserved_1, queue, exchange, routing_key, no_wait, arguments, - }, + }), )) } fn queue_bind_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; - Ok((input, Method::QueueBindOk {})) + Ok((input, Method::QueueBindOk(QueueBindOk {}))) } fn queue_unbind(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(50_u16.to_be_bytes())(input)?; @@ -511,18 +520,18 @@ pub mod parse { domain_table(input).map_err(fail_err("field arguments in method unbind"))?; Ok(( input, - Method::QueueUnbind { + Method::QueueUnbind(QueueUnbind { reserved_1, queue, exchange, routing_key, arguments, - }, + }), )) } fn queue_unbind_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(51_u16.to_be_bytes())(input)?; - Ok((input, Method::QueueUnbindOk {})) + Ok((input, Method::QueueUnbindOk(QueueUnbindOk {}))) } fn queue_purge(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(30_u16.to_be_bytes())(input)?; @@ -534,18 +543,18 @@ pub mod parse { let no_wait = bits[0]; Ok(( input, - Method::QueuePurge { + Method::QueuePurge(QueuePurge { reserved_1, queue, no_wait, - }, + }), )) } fn queue_purge_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(31_u16.to_be_bytes())(input)?; let (input, message_count) = domain_message_count(input) .map_err(fail_err("field message-count in method purge-ok"))?; - Ok((input, Method::QueuePurgeOk { message_count })) + Ok((input, Method::QueuePurgeOk(QueuePurgeOk { message_count }))) } fn queue_delete(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(40_u16.to_be_bytes())(input)?; @@ -559,20 +568,23 @@ pub mod parse { let no_wait = bits[2]; Ok(( input, - Method::QueueDelete { + Method::QueueDelete(QueueDelete { reserved_1, queue, if_unused, if_empty, no_wait, - }, + }), )) } fn queue_delete_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(41_u16.to_be_bytes())(input)?; let (input, message_count) = domain_message_count(input) .map_err(fail_err("field message-count in method delete-ok"))?; - Ok((input, Method::QueueDeleteOk { message_count })) + Ok(( + input, + Method::QueueDeleteOk(QueueDeleteOk { message_count }), + )) } fn basic(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(60_u16.to_be_bytes())(input)?; @@ -607,16 +619,16 @@ pub mod parse { let global = bits[0]; Ok(( input, - Method::BasicQos { + Method::BasicQos(BasicQos { prefetch_size, prefetch_count, global, - }, + }), )) } fn basic_qos_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(11_u16.to_be_bytes())(input)?; - Ok((input, Method::BasicQosOk {})) + Ok((input, Method::BasicQosOk(BasicQosOk {}))) } fn basic_consume(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; @@ -635,7 +647,7 @@ pub mod parse { domain_table(input).map_err(fail_err("field arguments in method consume"))?; Ok(( input, - Method::BasicConsume { + Method::BasicConsume(BasicConsume { reserved_1, queue, consumer_tag, @@ -644,14 +656,17 @@ pub mod parse { exclusive, no_wait, arguments, - }, + }), )) } fn basic_consume_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; let (input, consumer_tag) = domain_consumer_tag(input) .map_err(fail_err("field consumer-tag in method consume-ok"))?; - Ok((input, Method::BasicConsumeOk { consumer_tag })) + Ok(( + input, + Method::BasicConsumeOk(BasicConsumeOk { consumer_tag }), + )) } fn basic_cancel(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(30_u16.to_be_bytes())(input)?; @@ -661,17 +676,17 @@ pub mod parse { let no_wait = bits[0]; Ok(( input, - Method::BasicCancel { + Method::BasicCancel(BasicCancel { consumer_tag, no_wait, - }, + }), )) } fn basic_cancel_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(31_u16.to_be_bytes())(input)?; let (input, consumer_tag) = domain_consumer_tag(input) .map_err(fail_err("field consumer-tag in method cancel-ok"))?; - Ok((input, Method::BasicCancelOk { consumer_tag })) + Ok((input, Method::BasicCancelOk(BasicCancelOk { consumer_tag }))) } fn basic_publish(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(40_u16.to_be_bytes())(input)?; @@ -686,13 +701,13 @@ pub mod parse { let immediate = bits[1]; Ok(( input, - Method::BasicPublish { + Method::BasicPublish(BasicPublish { reserved_1, exchange, routing_key, mandatory, immediate, - }, + }), )) } fn basic_return(input: &[u8]) -> IResult<'_, Method> { @@ -707,12 +722,12 @@ pub mod parse { domain_shortstr(input).map_err(fail_err("field routing-key in method return"))?; Ok(( input, - Method::BasicReturn { + Method::BasicReturn(BasicReturn { reply_code, reply_text, exchange, routing_key, - }, + }), )) } fn basic_deliver(input: &[u8]) -> IResult<'_, Method> { @@ -730,13 +745,13 @@ pub mod parse { domain_shortstr(input).map_err(fail_err("field routing-key in method deliver"))?; Ok(( input, - Method::BasicDeliver { + Method::BasicDeliver(BasicDeliver { consumer_tag, delivery_tag, redelivered, exchange, routing_key, - }, + }), )) } fn basic_get(input: &[u8]) -> IResult<'_, Method> { @@ -749,11 +764,11 @@ pub mod parse { let no_ack = bits[0]; Ok(( input, - Method::BasicGet { + Method::BasicGet(BasicGet { reserved_1, queue, no_ack, - }, + }), )) } fn basic_get_ok(input: &[u8]) -> IResult<'_, Method> { @@ -771,20 +786,20 @@ pub mod parse { .map_err(fail_err("field message-count in method get-ok"))?; Ok(( input, - Method::BasicGetOk { + Method::BasicGetOk(BasicGetOk { delivery_tag, redelivered, exchange, routing_key, message_count, - }, + }), )) } fn basic_get_empty(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(72_u16.to_be_bytes())(input)?; let (input, reserved_1) = domain_shortstr(input).map_err(fail_err("field reserved-1 in method get-empty"))?; - Ok((input, Method::BasicGetEmpty { reserved_1 })) + Ok((input, Method::BasicGetEmpty(BasicGetEmpty { reserved_1 }))) } fn basic_ack(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(80_u16.to_be_bytes())(input)?; @@ -794,10 +809,10 @@ pub mod parse { let multiple = bits[0]; Ok(( input, - Method::BasicAck { + Method::BasicAck(BasicAck { delivery_tag, multiple, - }, + }), )) } fn basic_reject(input: &[u8]) -> IResult<'_, Method> { @@ -808,10 +823,10 @@ pub mod parse { let requeue = bits[0]; Ok(( input, - Method::BasicReject { + Method::BasicReject(BasicReject { delivery_tag, requeue, - }, + }), )) } fn basic_recover_async(input: &[u8]) -> IResult<'_, Method> { @@ -819,17 +834,20 @@ pub mod parse { let (input, bits) = bit(input, 1).map_err(fail_err("field requeue in method recover-async"))?; let requeue = bits[0]; - Ok((input, Method::BasicRecoverAsync { requeue })) + Ok(( + input, + Method::BasicRecoverAsync(BasicRecoverAsync { requeue }), + )) } fn basic_recover(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(110_u16.to_be_bytes())(input)?; let (input, bits) = bit(input, 1).map_err(fail_err("field requeue in method recover"))?; let requeue = bits[0]; - Ok((input, Method::BasicRecover { requeue })) + Ok((input, Method::BasicRecover(BasicRecover { requeue }))) } fn basic_recover_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(111_u16.to_be_bytes())(input)?; - Ok((input, Method::BasicRecoverOk {})) + Ok((input, Method::BasicRecoverOk(BasicRecoverOk {}))) } fn tx(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(90_u16.to_be_bytes())(input)?; @@ -845,27 +863,27 @@ pub mod parse { } fn tx_select(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(10_u16.to_be_bytes())(input)?; - Ok((input, Method::TxSelect {})) + Ok((input, Method::TxSelect(TxSelect {}))) } fn tx_select_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(11_u16.to_be_bytes())(input)?; - Ok((input, Method::TxSelectOk {})) + Ok((input, Method::TxSelectOk(TxSelectOk {}))) } fn tx_commit(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(20_u16.to_be_bytes())(input)?; - Ok((input, Method::TxCommit {})) + Ok((input, Method::TxCommit(TxCommit {}))) } fn tx_commit_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(21_u16.to_be_bytes())(input)?; - Ok((input, Method::TxCommitOk {})) + Ok((input, Method::TxCommitOk(TxCommitOk {}))) } fn tx_rollback(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(30_u16.to_be_bytes())(input)?; - Ok((input, Method::TxRollback {})) + Ok((input, Method::TxRollback(TxRollback {}))) } fn tx_rollback_ok(input: &[u8]) -> IResult<'_, Method> { let (input, _) = tag(31_u16.to_be_bytes())(input)?; - Ok((input, Method::TxRollbackOk {})) + Ok((input, Method::TxRollbackOk(TxRollbackOk {}))) } } pub mod write { @@ -876,13 +894,13 @@ pub mod write { pub fn write_method(method: Method, mut writer: W) -> Result<(), TransError> { match method { - Method::ConnectionStart { + Method::ConnectionStart(ConnectionStart { version_major, version_minor, server_properties, mechanisms, locales, - } => { + }) => { writer.write_all(&[0, 10, 0, 10])?; octet(version_major, &mut writer)?; octet(version_minor, &mut writer)?; @@ -890,107 +908,107 @@ pub mod write { longstr(mechanisms, &mut writer)?; longstr(locales, &mut writer)?; } - Method::ConnectionStartOk { + Method::ConnectionStartOk(ConnectionStartOk { client_properties, mechanism, response, locale, - } => { + }) => { writer.write_all(&[0, 10, 0, 11])?; table(client_properties, &mut writer)?; shortstr(mechanism, &mut writer)?; longstr(response, &mut writer)?; shortstr(locale, &mut writer)?; } - Method::ConnectionSecure { challenge } => { + Method::ConnectionSecure(ConnectionSecure { challenge }) => { writer.write_all(&[0, 10, 0, 20])?; longstr(challenge, &mut writer)?; } - Method::ConnectionSecureOk { response } => { + Method::ConnectionSecureOk(ConnectionSecureOk { response }) => { writer.write_all(&[0, 10, 0, 21])?; longstr(response, &mut writer)?; } - Method::ConnectionTune { + Method::ConnectionTune(ConnectionTune { channel_max, frame_max, heartbeat, - } => { + }) => { writer.write_all(&[0, 10, 0, 30])?; short(channel_max, &mut writer)?; long(frame_max, &mut writer)?; short(heartbeat, &mut writer)?; } - Method::ConnectionTuneOk { + Method::ConnectionTuneOk(ConnectionTuneOk { channel_max, frame_max, heartbeat, - } => { + }) => { writer.write_all(&[0, 10, 0, 31])?; short(channel_max, &mut writer)?; long(frame_max, &mut writer)?; short(heartbeat, &mut writer)?; } - Method::ConnectionOpen { + Method::ConnectionOpen(ConnectionOpen { virtual_host, reserved_1, reserved_2, - } => { + }) => { writer.write_all(&[0, 10, 0, 40])?; shortstr(virtual_host, &mut writer)?; shortstr(reserved_1, &mut writer)?; bit(&[reserved_2], &mut writer)?; } - Method::ConnectionOpenOk { reserved_1 } => { + Method::ConnectionOpenOk(ConnectionOpenOk { reserved_1 }) => { writer.write_all(&[0, 10, 0, 41])?; shortstr(reserved_1, &mut writer)?; } - Method::ConnectionClose { + Method::ConnectionClose(ConnectionClose { reply_code, reply_text, class_id, method_id, - } => { + }) => { writer.write_all(&[0, 10, 0, 50])?; short(reply_code, &mut writer)?; shortstr(reply_text, &mut writer)?; short(class_id, &mut writer)?; short(method_id, &mut writer)?; } - Method::ConnectionCloseOk {} => { + Method::ConnectionCloseOk(ConnectionCloseOk {}) => { writer.write_all(&[0, 10, 0, 51])?; } - Method::ChannelOpen { reserved_1 } => { + Method::ChannelOpen(ChannelOpen { reserved_1 }) => { writer.write_all(&[0, 20, 0, 10])?; shortstr(reserved_1, &mut writer)?; } - Method::ChannelOpenOk { reserved_1 } => { + Method::ChannelOpenOk(ChannelOpenOk { reserved_1 }) => { writer.write_all(&[0, 20, 0, 11])?; longstr(reserved_1, &mut writer)?; } - Method::ChannelFlow { active } => { + Method::ChannelFlow(ChannelFlow { active }) => { writer.write_all(&[0, 20, 0, 20])?; bit(&[active], &mut writer)?; } - Method::ChannelFlowOk { active } => { + Method::ChannelFlowOk(ChannelFlowOk { active }) => { writer.write_all(&[0, 20, 0, 21])?; bit(&[active], &mut writer)?; } - Method::ChannelClose { + Method::ChannelClose(ChannelClose { reply_code, reply_text, class_id, method_id, - } => { + }) => { writer.write_all(&[0, 20, 0, 40])?; short(reply_code, &mut writer)?; shortstr(reply_text, &mut writer)?; short(class_id, &mut writer)?; short(method_id, &mut writer)?; } - Method::ChannelCloseOk {} => { + Method::ChannelCloseOk(ChannelCloseOk {}) => { writer.write_all(&[0, 20, 0, 41])?; } - Method::ExchangeDeclare { + Method::ExchangeDeclare(ExchangeDeclare { reserved_1, exchange, r#type, @@ -1000,7 +1018,7 @@ pub mod write { reserved_3, no_wait, arguments, - } => { + }) => { writer.write_all(&[0, 40, 0, 10])?; short(reserved_1, &mut writer)?; shortstr(exchange, &mut writer)?; @@ -1011,24 +1029,24 @@ pub mod write { )?; table(arguments, &mut writer)?; } - Method::ExchangeDeclareOk {} => { + Method::ExchangeDeclareOk(ExchangeDeclareOk {}) => { writer.write_all(&[0, 40, 0, 11])?; } - Method::ExchangeDelete { + Method::ExchangeDelete(ExchangeDelete { reserved_1, exchange, if_unused, no_wait, - } => { + }) => { writer.write_all(&[0, 40, 0, 20])?; short(reserved_1, &mut writer)?; shortstr(exchange, &mut writer)?; bit(&[if_unused, no_wait], &mut writer)?; } - Method::ExchangeDeleteOk {} => { + Method::ExchangeDeleteOk(ExchangeDeleteOk {}) => { writer.write_all(&[0, 40, 0, 21])?; } - Method::QueueDeclare { + Method::QueueDeclare(QueueDeclare { reserved_1, queue, passive, @@ -1037,7 +1055,7 @@ pub mod write { auto_delete, no_wait, arguments, - } => { + }) => { writer.write_all(&[0, 50, 0, 10])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; @@ -1047,24 +1065,24 @@ pub mod write { )?; table(arguments, &mut writer)?; } - Method::QueueDeclareOk { + Method::QueueDeclareOk(QueueDeclareOk { queue, message_count, consumer_count, - } => { + }) => { writer.write_all(&[0, 50, 0, 11])?; shortstr(queue, &mut writer)?; long(message_count, &mut writer)?; long(consumer_count, &mut writer)?; } - Method::QueueBind { + Method::QueueBind(QueueBind { reserved_1, queue, exchange, routing_key, no_wait, arguments, - } => { + }) => { writer.write_all(&[0, 50, 0, 20])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; @@ -1073,16 +1091,16 @@ pub mod write { bit(&[no_wait], &mut writer)?; table(arguments, &mut writer)?; } - Method::QueueBindOk {} => { + Method::QueueBindOk(QueueBindOk {}) => { writer.write_all(&[0, 50, 0, 21])?; } - Method::QueueUnbind { + Method::QueueUnbind(QueueUnbind { reserved_1, queue, exchange, routing_key, arguments, - } => { + }) => { writer.write_all(&[0, 50, 0, 50])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; @@ -1090,53 +1108,53 @@ pub mod write { shortstr(routing_key, &mut writer)?; table(arguments, &mut writer)?; } - Method::QueueUnbindOk {} => { + Method::QueueUnbindOk(QueueUnbindOk {}) => { writer.write_all(&[0, 50, 0, 51])?; } - Method::QueuePurge { + Method::QueuePurge(QueuePurge { reserved_1, queue, no_wait, - } => { + }) => { writer.write_all(&[0, 50, 0, 30])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; bit(&[no_wait], &mut writer)?; } - Method::QueuePurgeOk { message_count } => { + Method::QueuePurgeOk(QueuePurgeOk { message_count }) => { writer.write_all(&[0, 50, 0, 31])?; long(message_count, &mut writer)?; } - Method::QueueDelete { + Method::QueueDelete(QueueDelete { reserved_1, queue, if_unused, if_empty, no_wait, - } => { + }) => { writer.write_all(&[0, 50, 0, 40])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; bit(&[if_unused, if_empty, no_wait], &mut writer)?; } - Method::QueueDeleteOk { message_count } => { + Method::QueueDeleteOk(QueueDeleteOk { message_count }) => { writer.write_all(&[0, 50, 0, 41])?; long(message_count, &mut writer)?; } - Method::BasicQos { + Method::BasicQos(BasicQos { prefetch_size, prefetch_count, global, - } => { + }) => { writer.write_all(&[0, 60, 0, 10])?; long(prefetch_size, &mut writer)?; short(prefetch_count, &mut writer)?; bit(&[global], &mut writer)?; } - Method::BasicQosOk {} => { + Method::BasicQosOk(BasicQosOk {}) => { writer.write_all(&[0, 60, 0, 11])?; } - Method::BasicConsume { + Method::BasicConsume(BasicConsume { reserved_1, queue, consumer_tag, @@ -1145,7 +1163,7 @@ pub mod write { exclusive, no_wait, arguments, - } => { + }) => { writer.write_all(&[0, 60, 0, 20])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; @@ -1153,54 +1171,54 @@ pub mod write { bit(&[no_local, no_ack, exclusive, no_wait], &mut writer)?; table(arguments, &mut writer)?; } - Method::BasicConsumeOk { consumer_tag } => { + Method::BasicConsumeOk(BasicConsumeOk { consumer_tag }) => { writer.write_all(&[0, 60, 0, 21])?; shortstr(consumer_tag, &mut writer)?; } - Method::BasicCancel { + Method::BasicCancel(BasicCancel { consumer_tag, no_wait, - } => { + }) => { writer.write_all(&[0, 60, 0, 30])?; shortstr(consumer_tag, &mut writer)?; bit(&[no_wait], &mut writer)?; } - Method::BasicCancelOk { consumer_tag } => { + Method::BasicCancelOk(BasicCancelOk { consumer_tag }) => { writer.write_all(&[0, 60, 0, 31])?; shortstr(consumer_tag, &mut writer)?; } - Method::BasicPublish { + Method::BasicPublish(BasicPublish { reserved_1, exchange, routing_key, mandatory, immediate, - } => { + }) => { writer.write_all(&[0, 60, 0, 40])?; short(reserved_1, &mut writer)?; shortstr(exchange, &mut writer)?; shortstr(routing_key, &mut writer)?; bit(&[mandatory, immediate], &mut writer)?; } - Method::BasicReturn { + Method::BasicReturn(BasicReturn { reply_code, reply_text, exchange, routing_key, - } => { + }) => { writer.write_all(&[0, 60, 0, 50])?; short(reply_code, &mut writer)?; shortstr(reply_text, &mut writer)?; shortstr(exchange, &mut writer)?; shortstr(routing_key, &mut writer)?; } - Method::BasicDeliver { + Method::BasicDeliver(BasicDeliver { consumer_tag, delivery_tag, redelivered, exchange, routing_key, - } => { + }) => { writer.write_all(&[0, 60, 0, 60])?; shortstr(consumer_tag, &mut writer)?; longlong(delivery_tag, &mut writer)?; @@ -1208,23 +1226,23 @@ pub mod write { shortstr(exchange, &mut writer)?; shortstr(routing_key, &mut writer)?; } - Method::BasicGet { + Method::BasicGet(BasicGet { reserved_1, queue, no_ack, - } => { + }) => { writer.write_all(&[0, 60, 0, 70])?; short(reserved_1, &mut writer)?; shortstr(queue, &mut writer)?; bit(&[no_ack], &mut writer)?; } - Method::BasicGetOk { + Method::BasicGetOk(BasicGetOk { delivery_tag, redelivered, exchange, routing_key, message_count, - } => { + }) => { writer.write_all(&[0, 60, 0, 71])?; longlong(delivery_tag, &mut writer)?; bit(&[redelivered], &mut writer)?; @@ -1232,53 +1250,53 @@ pub mod write { shortstr(routing_key, &mut writer)?; long(message_count, &mut writer)?; } - Method::BasicGetEmpty { reserved_1 } => { + Method::BasicGetEmpty(BasicGetEmpty { reserved_1 }) => { writer.write_all(&[0, 60, 0, 72])?; shortstr(reserved_1, &mut writer)?; } - Method::BasicAck { + Method::BasicAck(BasicAck { delivery_tag, multiple, - } => { + }) => { writer.write_all(&[0, 60, 0, 80])?; longlong(delivery_tag, &mut writer)?; bit(&[multiple], &mut writer)?; } - Method::BasicReject { + Method::BasicReject(BasicReject { delivery_tag, requeue, - } => { + }) => { writer.write_all(&[0, 60, 0, 90])?; longlong(delivery_tag, &mut writer)?; bit(&[requeue], &mut writer)?; } - Method::BasicRecoverAsync { requeue } => { + Method::BasicRecoverAsync(BasicRecoverAsync { requeue }) => { writer.write_all(&[0, 60, 0, 100])?; bit(&[requeue], &mut writer)?; } - Method::BasicRecover { requeue } => { + Method::BasicRecover(BasicRecover { requeue }) => { writer.write_all(&[0, 60, 0, 110])?; bit(&[requeue], &mut writer)?; } - Method::BasicRecoverOk {} => { + Method::BasicRecoverOk(BasicRecoverOk {}) => { writer.write_all(&[0, 60, 0, 111])?; } - Method::TxSelect {} => { + Method::TxSelect(TxSelect {}) => { writer.write_all(&[0, 90, 0, 10])?; } - Method::TxSelectOk {} => { + Method::TxSelectOk(TxSelectOk {}) => { writer.write_all(&[0, 90, 0, 11])?; } - Method::TxCommit {} => { + Method::TxCommit(TxCommit {}) => { writer.write_all(&[0, 90, 0, 20])?; } - Method::TxCommitOk {} => { + Method::TxCommitOk(TxCommitOk {}) => { writer.write_all(&[0, 90, 0, 21])?; } - Method::TxRollback {} => { + Method::TxRollback(TxRollback {}) => { writer.write_all(&[0, 90, 0, 30])?; } - Method::TxRollbackOk {} => { + Method::TxRollbackOk(TxRollbackOk {}) => { writer.write_all(&[0, 90, 0, 31])?; } } @@ -1296,76 +1314,76 @@ mod random { fn random(rng: &mut R) -> Self { match rng.gen_range(0u32..6) { 0 => match rng.gen_range(0u32..10) { - 0 => Method::ConnectionStart { + 0 => Method::ConnectionStart(ConnectionStart { version_major: RandomMethod::random(rng), version_minor: RandomMethod::random(rng), server_properties: RandomMethod::random(rng), mechanisms: RandomMethod::random(rng), locales: RandomMethod::random(rng), - }, - 1 => Method::ConnectionStartOk { + }), + 1 => Method::ConnectionStartOk(ConnectionStartOk { client_properties: RandomMethod::random(rng), mechanism: RandomMethod::random(rng), response: RandomMethod::random(rng), locale: RandomMethod::random(rng), - }, - 2 => Method::ConnectionSecure { + }), + 2 => Method::ConnectionSecure(ConnectionSecure { challenge: RandomMethod::random(rng), - }, - 3 => Method::ConnectionSecureOk { + }), + 3 => Method::ConnectionSecureOk(ConnectionSecureOk { response: RandomMethod::random(rng), - }, - 4 => Method::ConnectionTune { + }), + 4 => Method::ConnectionTune(ConnectionTune { channel_max: RandomMethod::random(rng), frame_max: RandomMethod::random(rng), heartbeat: RandomMethod::random(rng), - }, - 5 => Method::ConnectionTuneOk { + }), + 5 => Method::ConnectionTuneOk(ConnectionTuneOk { channel_max: RandomMethod::random(rng), frame_max: RandomMethod::random(rng), heartbeat: RandomMethod::random(rng), - }, - 6 => Method::ConnectionOpen { + }), + 6 => Method::ConnectionOpen(ConnectionOpen { virtual_host: RandomMethod::random(rng), reserved_1: RandomMethod::random(rng), reserved_2: RandomMethod::random(rng), - }, - 7 => Method::ConnectionOpenOk { + }), + 7 => Method::ConnectionOpenOk(ConnectionOpenOk { reserved_1: RandomMethod::random(rng), - }, - 8 => Method::ConnectionClose { + }), + 8 => Method::ConnectionClose(ConnectionClose { reply_code: RandomMethod::random(rng), reply_text: RandomMethod::random(rng), class_id: RandomMethod::random(rng), method_id: RandomMethod::random(rng), - }, - 9 => Method::ConnectionCloseOk {}, + }), + 9 => Method::ConnectionCloseOk(ConnectionCloseOk {}), _ => unreachable!(), }, 1 => match rng.gen_range(0u32..6) { - 0 => Method::ChannelOpen { + 0 => Method::ChannelOpen(ChannelOpen { reserved_1: RandomMethod::random(rng), - }, - 1 => Method::ChannelOpenOk { + }), + 1 => Method::ChannelOpenOk(ChannelOpenOk { reserved_1: RandomMethod::random(rng), - }, - 2 => Method::ChannelFlow { + }), + 2 => Method::ChannelFlow(ChannelFlow { active: RandomMethod::random(rng), - }, - 3 => Method::ChannelFlowOk { + }), + 3 => Method::ChannelFlowOk(ChannelFlowOk { active: RandomMethod::random(rng), - }, - 4 => Method::ChannelClose { + }), + 4 => Method::ChannelClose(ChannelClose { reply_code: RandomMethod::random(rng), reply_text: RandomMethod::random(rng), class_id: RandomMethod::random(rng), method_id: RandomMethod::random(rng), - }, - 5 => Method::ChannelCloseOk {}, + }), + 5 => Method::ChannelCloseOk(ChannelCloseOk {}), _ => unreachable!(), }, 2 => match rng.gen_range(0u32..4) { - 0 => Method::ExchangeDeclare { + 0 => Method::ExchangeDeclare(ExchangeDeclare { reserved_1: RandomMethod::random(rng), exchange: RandomMethod::random(rng), r#type: RandomMethod::random(rng), @@ -1375,19 +1393,19 @@ mod random { reserved_3: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), arguments: RandomMethod::random(rng), - }, - 1 => Method::ExchangeDeclareOk {}, - 2 => Method::ExchangeDelete { + }), + 1 => Method::ExchangeDeclareOk(ExchangeDeclareOk {}), + 2 => Method::ExchangeDelete(ExchangeDelete { reserved_1: RandomMethod::random(rng), exchange: RandomMethod::random(rng), if_unused: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), - }, - 3 => Method::ExchangeDeleteOk {}, + }), + 3 => Method::ExchangeDeleteOk(ExchangeDeleteOk {}), _ => unreachable!(), }, 3 => match rng.gen_range(0u32..10) { - 0 => Method::QueueDeclare { + 0 => Method::QueueDeclare(QueueDeclare { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), passive: RandomMethod::random(rng), @@ -1396,57 +1414,57 @@ mod random { auto_delete: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), arguments: RandomMethod::random(rng), - }, - 1 => Method::QueueDeclareOk { + }), + 1 => Method::QueueDeclareOk(QueueDeclareOk { queue: RandomMethod::random(rng), message_count: RandomMethod::random(rng), consumer_count: RandomMethod::random(rng), - }, - 2 => Method::QueueBind { + }), + 2 => Method::QueueBind(QueueBind { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), arguments: RandomMethod::random(rng), - }, - 3 => Method::QueueBindOk {}, - 4 => Method::QueueUnbind { + }), + 3 => Method::QueueBindOk(QueueBindOk {}), + 4 => Method::QueueUnbind(QueueUnbind { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), arguments: RandomMethod::random(rng), - }, - 5 => Method::QueueUnbindOk {}, - 6 => Method::QueuePurge { + }), + 5 => Method::QueueUnbindOk(QueueUnbindOk {}), + 6 => Method::QueuePurge(QueuePurge { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), - }, - 7 => Method::QueuePurgeOk { + }), + 7 => Method::QueuePurgeOk(QueuePurgeOk { message_count: RandomMethod::random(rng), - }, - 8 => Method::QueueDelete { + }), + 8 => Method::QueueDelete(QueueDelete { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), if_unused: RandomMethod::random(rng), if_empty: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), - }, - 9 => Method::QueueDeleteOk { + }), + 9 => Method::QueueDeleteOk(QueueDeleteOk { message_count: RandomMethod::random(rng), - }, + }), _ => unreachable!(), }, 4 => match rng.gen_range(0u32..17) { - 0 => Method::BasicQos { + 0 => Method::BasicQos(BasicQos { prefetch_size: RandomMethod::random(rng), prefetch_count: RandomMethod::random(rng), global: RandomMethod::random(rng), - }, - 1 => Method::BasicQosOk {}, - 2 => Method::BasicConsume { + }), + 1 => Method::BasicQosOk(BasicQosOk {}), + 2 => Method::BasicConsume(BasicConsume { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), consumer_tag: RandomMethod::random(rng), @@ -1455,76 +1473,76 @@ mod random { exclusive: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), arguments: RandomMethod::random(rng), - }, - 3 => Method::BasicConsumeOk { + }), + 3 => Method::BasicConsumeOk(BasicConsumeOk { consumer_tag: RandomMethod::random(rng), - }, - 4 => Method::BasicCancel { + }), + 4 => Method::BasicCancel(BasicCancel { consumer_tag: RandomMethod::random(rng), no_wait: RandomMethod::random(rng), - }, - 5 => Method::BasicCancelOk { + }), + 5 => Method::BasicCancelOk(BasicCancelOk { consumer_tag: RandomMethod::random(rng), - }, - 6 => Method::BasicPublish { + }), + 6 => Method::BasicPublish(BasicPublish { reserved_1: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), mandatory: RandomMethod::random(rng), immediate: RandomMethod::random(rng), - }, - 7 => Method::BasicReturn { + }), + 7 => Method::BasicReturn(BasicReturn { reply_code: RandomMethod::random(rng), reply_text: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), - }, - 8 => Method::BasicDeliver { + }), + 8 => Method::BasicDeliver(BasicDeliver { consumer_tag: RandomMethod::random(rng), delivery_tag: RandomMethod::random(rng), redelivered: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), - }, - 9 => Method::BasicGet { + }), + 9 => Method::BasicGet(BasicGet { reserved_1: RandomMethod::random(rng), queue: RandomMethod::random(rng), no_ack: RandomMethod::random(rng), - }, - 10 => Method::BasicGetOk { + }), + 10 => Method::BasicGetOk(BasicGetOk { delivery_tag: RandomMethod::random(rng), redelivered: RandomMethod::random(rng), exchange: RandomMethod::random(rng), routing_key: RandomMethod::random(rng), message_count: RandomMethod::random(rng), - }, - 11 => Method::BasicGetEmpty { + }), + 11 => Method::BasicGetEmpty(BasicGetEmpty { reserved_1: RandomMethod::random(rng), - }, - 12 => Method::BasicAck { + }), + 12 => Method::BasicAck(BasicAck { delivery_tag: RandomMethod::random(rng), multiple: RandomMethod::random(rng), - }, - 13 => Method::BasicReject { + }), + 13 => Method::BasicReject(BasicReject { delivery_tag: RandomMethod::random(rng), requeue: RandomMethod::random(rng), - }, - 14 => Method::BasicRecoverAsync { + }), + 14 => Method::BasicRecoverAsync(BasicRecoverAsync { requeue: RandomMethod::random(rng), - }, - 15 => Method::BasicRecover { + }), + 15 => Method::BasicRecover(BasicRecover { requeue: RandomMethod::random(rng), - }, - 16 => Method::BasicRecoverOk {}, + }), + 16 => Method::BasicRecoverOk(BasicRecoverOk {}), _ => unreachable!(), }, 5 => match rng.gen_range(0u32..6) { - 0 => Method::TxSelect {}, - 1 => Method::TxSelectOk {}, - 2 => Method::TxCommit {}, - 3 => Method::TxCommitOk {}, - 4 => Method::TxRollback {}, - 5 => Method::TxRollbackOk {}, + 0 => Method::TxSelect(TxSelect {}), + 1 => Method::TxSelectOk(TxSelectOk {}), + 2 => Method::TxCommit(TxCommit {}), + 3 => Method::TxCommitOk(TxCommitOk {}), + 4 => Method::TxRollback(TxRollback {}), + 5 => Method::TxRollbackOk(TxRollbackOk {}), _ => unreachable!(), }, _ => unreachable!(), diff --git a/amqp_transport/src/tests.rs b/amqp_transport/src/tests.rs index cb61337..f12c4d7 100644 --- a/amqp_transport/src/tests.rs +++ b/amqp_transport/src/tests.rs @@ -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() - } + }) ); } diff --git a/xtask/src/codegen/mod.rs b/xtask/src/codegen/mod.rs index 9600df1..bd66ad2 100644 --- a/xtask/src/codegen/mod.rs +++ b/xtask/src/codegen/mod.rs @@ -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 { @@ -225,24 +245,22 @@ impl Codegen { field.asserts.as_ref(), ); if !field_docs.is_empty() { - writeln!(self.output, " /// {field_docs}").ok(); + writeln!(self.output, " /// {field_docs}").ok(); if !field.doc.is_empty() { - writeln!(self.output, " ///").ok(); - self.doc_comment(&field.doc, 8); + writeln!(self.output, " ///").ok(); + 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(); + writeln!(self.output, " }}\n").ok(); } else { - writeln!(self.output, ",").ok(); + writeln!(self.output, ";\n").ok(); } } } - - writeln!(self.output, "}}\n").ok(); } fn amqp_type_to_rust_type(&self, amqp_type: &str) -> &'static str { diff --git a/xtask/src/codegen/parser.rs b/xtask/src/codegen/parser.rs index 1e3ecea..cd68b52 100644 --- a/xtask/src/codegen/parser.rs +++ b/xtask/src/codegen/parser.rs @@ -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(); } diff --git a/xtask/src/codegen/random.rs b/xtask/src/codegen/random.rs index 6dbb287..9ab1442 100644 --- a/xtask/src/codegen/random.rs +++ b/xtask/src/codegen/random.rs @@ -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, diff --git a/xtask/src/codegen/write.rs b/xtask/src/codegen/write.rs index 104e5df..e725121 100644 --- a/xtask/src/codegen/write.rs +++ b/xtask/src/codegen/write.rs @@ -22,12 +22,16 @@ pub fn write_method(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!(