Struct Ticket 

pub struct Ticket<S: Service> {
    pub service: ServiceId,
    pub id: String,
    pub data: S::TicketData,
}

Ticket to use a service.

This must be issued by a trusted backend for use in the (untrusted) frontend.

It carries

• an identifier of the service that is intended to be used,
• an arbitrary ticket identifier for verifying the results later on and
• any critical input data for the service.

The ticket data gets wrapped in a JSON Web Token as claim data. The token must also contain an expiry in the claim exp and the key identifier in the kid header field.

Example issuance of an Authenticated<Ticket<accounts::Service>> for the accounts service:

use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use serde::Serialize;
use std::time::{SystemTime, UNIX_EPOCH};
use uuid::Uuid;

let ticket_id = Uuid::new_v4().to_string();

#[derive(Serialize, Debug)]
struct Ticket<T> {
    service: String,
    id: String,
    data: T,
}

#[derive(Serialize, Debug)]
struct Claims<T> {
    data: Ticket<T>,
    exp: u64,
}

let header = Header {
    alg: Algorithm::HS256,
    kid: Some(HMAC_KEY_ID.to_string()),
    ..Default::default()
};

let authenticated_ticket = encode(
    &header,
    &Claims {
        data: Ticket {
            service: "Accounts".to_string(),
            id: ticket_id,
            data: (),
        },
        exp: SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards").as_secs() + 600,
    },
    &EncodingKey::from_secret(HMAC_KEY),
)?;

Fields

service: ServiceId

id: String

data: S::TicketData

Trait Implementations

impl<S: Service> Clone for Ticket<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Service> Debug for Ticket<S>

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

Formats the value using the given formatter.

impl<'de, S: Service> Deserialize<'de> for Ticket<S>

where S::TicketData: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Service> PartialEq for Ticket<S>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S: Service> Serialize for Ticket<S>

where S::TicketData: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Service> Eq for Ticket<S>