Struct rocket::serde::msgpack::MsgPack

pub struct MsgPack<T>(pub T);

Available on crate feature msgpack only.

The MessagePack guard: easily consume and return MessagePack.

Sending MessagePack

To respond with serialized MessagePack data, return a MsgPack<T> type, where T implements Serialize from serde. The content type of the response is set to application/msgpack automatically.

use rocket::serde::msgpack::MsgPack;

#[get("/users/<id>")]
fn user(id: usize) -> MsgPack<User> {
    let user_from_id = User::from(id);
    /* ... */
    MsgPack(user_from_id)
}

Receiving MessagePack

MsgPack is both a data guard and a form guard.

Data Guard

To deserialize request body data as MessagePack, add a data route argument with a target type of MsgPack<T>, where T is some type you’d like to parse from JSON. T must implement serde::Deserialize.

use rocket::serde::msgpack::MsgPack;

#[post("/users", format = "msgpack", data = "<user>")]
fn new_user(user: MsgPack<User>) {
    /* ... */
}

You don’t need to use format = "msgpack", but it may be what you want. Using format = msgpack means that any request that doesn’t specify “application/msgpack” as its first Content-Type: header parameter will not be routed to this handler.

Form Guard

MsgPack<T>, as a form guard, accepts value and data fields and parses the data as a T. Simple use MsgPack<T>:

use rocket::form::{Form, FromForm};
use rocket::serde::msgpack::MsgPack;

#[derive(FromForm)]
struct User<'r> {
    name: &'r str,
    metadata: MsgPack<Metadata>
}

#[post("/users", data = "<form>")]
fn new_user(form: Form<User<'_>>) {
    /* ... */
}

Incoming Data Limits

The default size limit for incoming MessagePack data is 1MiB. Setting a limit protects your application from denial of service (DOS) attacks and from resource exhaustion through high memory consumption. The limit can be increased by setting the limits.msgpack configuration parameter. For instance, to increase the MessagePack limit to 5MiB for all environments, you may add the following to your Rocket.toml:

[global.limits]
msgpack = 5242880

Tuple Fields

0: T

Implementations

impl<T> MsgPack<T>

pub fn into_inner(self) -> T

Consumes the MsgPack wrapper and returns the wrapped item.

Example

let string = "Hello".to_string();
let my_msgpack = MsgPack(string);
assert_eq!(my_msgpack.into_inner(), "Hello".to_string());

Trait Implementations

impl<T: Clone> Clone for MsgPack<T>

fn clone(&self) -> MsgPack<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for MsgPack<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Deref for MsgPack<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for MsgPack<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T> From<T> for MsgPack<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'r, T: Deserialize<'r>> FromData<'r> for MsgPack<T>

type Error = Error

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>( req: &'r Request<'life0>, data: Data<'r> ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.

impl<'v, T: Deserialize<'v> + Send> FromFormField<'v> for MsgPack<T>

fn from_data<'life0, 'async_trait>( f: DataField<'v, 'life0> ) -> Pin<Box<dyn Future<Output = Result<Self, Errors<'v>>> + Send + 'async_trait>>

where Self: 'async_trait, 'v: 'async_trait, 'life0: 'async_trait,

Parse a value of T from a form data field.

fn from_value(field: ValueField<'v>) -> Result<'v, Self>

Parse a value of T from a form value field.

fn default() -> Option<Self>

Returns a default value, if any exists, to be used during lenient parsing when the form field is missing.

impl<T: Hash> Hash for MsgPack<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L, T: Len<L>> Len<L> for MsgPack<T>

fn len(&self) -> L

The length of the value.

fn len_into_u64(len: L) -> u64

Convert len into u64.

fn zero_len() -> L

The zero value for L.

impl<T: Ord> Ord for MsgPack<T>

fn cmp(&self, other: &MsgPack<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for MsgPack<T>

fn eq(&self, other: &MsgPack<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for MsgPack<T>

fn partial_cmp(&self, other: &MsgPack<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'r, T: Serialize> Responder<'r, 'static> for MsgPack<T>

Serializes the wrapped value into MessagePack. Returns a response with Content-Type MsgPack and a fixed-size body with the serialization. If serialization fails, an Err of Status::InternalServerError is returned.

fn respond_to(self, req: &'r Request<'_>) -> Result<'static>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.

impl<T: Eq> Eq for MsgPack<T>

impl<T> StructuralPartialEq for MsgPack<T>