Struct WebFingerRequest

pub struct WebFingerRequest {
    pub resource: Uri,
    pub host: String,
    pub rels: Vec<Rel>,
}

A WebFinger request.

This represents the request portion of a WebFinger query that can be executed against a WebFinger server.

See RFC 7033 Section 4 for more information.

Examples

use webfinger_rs::WebFingerRequest;

let request = WebFingerRequest::builder("acct:carol@example.com")?
    .host("example.com")
    .rel("http://webfinger.net/rel/profile-page")
    .build();

To execute the query, enable the reqwest feature and call query.execute().

let response = request.execute_reqwest().await?;

Request can be used as an Axum extractor as it implements axum::extract::FromRequestParts.

use webfinger_rs::{WebFingerRequest, WebFingerResponse};

async fn handler(request: WebFingerRequest) -> WebFingerResponse {
    // ... handle the request ...
}

Fields

resource: Uri

Query target.

This is the URI of the resource to query. It will be stored in the resource query parameter.

TODO: This could be a newtype that represents the resource and makes it easier to extract the values / parse into the right types (e.g. acct: URIs).

host: String

The host to query

TODO: this might be better as an Option<Uri> or Option<Host> or something similar. When the resource has a host part, it should be used unless this field is set.

rels: Vec<Rel>

Link relation types

This is a list of link relation types to query for. Each link relation type will be stored in a rel query parameter.

Implementations

impl WebFingerRequest

pub async fn execute_reqwest(&self) -> Result<WebFingerResponse, Error>

Available on crate feature reqwest only.

Executes the WebFinger request.

Examples

use webfinger_rs::WebFingerRequest;

let query = WebFingerRequest::builder("acct:carol@example.com")?
    .host("example.com")
    .rel("http://webfinger.net/rel/profile-page")
    .build();
let response = query.execute_reqwest().await?;

Examples found in repository

examples/client.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = WebFingerRequest::builder("acct:carol@example.com")?
        .host("example.com")
        .rel("http://webfinger.net/rel/profile-page")
        .build();
    let response = request.execute_reqwest().await?;
    dbg!(response);
    Ok(())
}

pub async fn execute_reqwest_with_client( &self, client: &Client, ) -> Result<WebFingerResponse, Error>

Available on crate feature reqwest only.

Executes the WebFinger request with a custom reqwest client.

pub fn try_into_reqwest(&self) -> Result<Request, Error>

Available on crate feature reqwest only.

Converts the WebFinger request into a reqwest request.

impl Request

pub fn new(resource: Uri) -> Self

Creates a new WebFinger request.

pub fn builder<U>(uri: U) -> Result<Builder, Error>

where Uri: TryFrom<U>, <Uri as TryFrom<U>>::Error: Into<Error>,

Creates a new [WebFingerBuilder] for a WebFinger request.

Examples found in repository

examples/client.rs (line 5)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = WebFingerRequest::builder("acct:carol@example.com")?
        .host("example.com")
        .rel("http://webfinger.net/rel/profile-page")
        .build();
    let response = request.execute_reqwest().await?;
    dbg!(response);
    Ok(())
}

Trait Implementations

impl Debug for Request

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Request

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromRequest for WebFingerRequest

Available on crate feature actix only.

type Error = Error

The associated error which can be returned.

type Future = Pin<Box<dyn Future<Output = Result<Request, <Request as FromRequest>::Error>> + Send>>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.

impl<S: Send + Sync> FromRequestParts<S> for WebFingerRequest

Available on crate feature axum only.

async fn from_request_parts( parts: &mut Parts, state: &S, ) -> Result<Self, Self::Rejection>

Extracts a WebFingerRequest from the request parts.

Errors

• If the request is missing the Host header, it will return a Bad Request response with the message “missing host”.

• If the resource query parameter is missing or invalid, it will return a Bad Request response with the message “invalid resource: {error}”.

• If the rel query parameter is invalid, it will return a Bad Request response with the message “invalid query string: {error}”.

See the axum example for more information.

Example

use axum::response::IntoResponse;
use webfinger_rs::WebFingerRequest;

async fn handler(request: WebFingerRequest) -> impl IntoResponse {
    let WebFingerRequest {
        host,
        resource,
        rels,
    } = request;
    // ... your code to handle the webfinger request ...
}

type Rejection = Rejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

impl Serialize for Request

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&Request> for PathAndQuery

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from(query: &WebFingerRequest) -> Result<PathAndQuery, InvalidUri>

Performs the conversion.

impl TryFrom<&Request> for Request

Available on crate feature reqwest only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(query: &WebFingerRequest) -> Result<Request, Error>

Performs the conversion.

impl TryFrom<&Request> for Request<EmptyBody>

Available on crate feature reqwest only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(query: &WebFingerRequest) -> Result<Request<EmptyBody>, Error>

Performs the conversion.

impl TryFrom<&Request> for Uri

type Error = Error

The type returned in the event of a conversion error.

fn try_from(query: &WebFingerRequest) -> Result<Uri, Error>

Performs the conversion.