use std::fmt;
use std::sync::Arc;
use std::time::Duration;
use crate::http::HttpClient;
use crate::types::SensitiveString;
mod device;
mod discovery;
mod pkce;
mod provider;
#[cfg(test)]
mod testing;
mod token;
mod transport;
pub use device::{
Clock, DEVICE_CODE_GRANT_TYPE, DeviceAuthorization, DeviceFlowError, DeviceFlowReason,
MAX_DEVICE_SECONDS, MonotonicClock,
};
pub use discovery::{
DiscoveryOutcome, FallbackReason, LAUNCHPAD_ISSUER, ProtectedResourceMetadata, SelectionError,
SelectionFailure, ServerMetadata, require_origin_root,
};
pub use pkce::{Pkce, generate_pkce, generate_state};
pub use provider::RefreshingTokenProvider;
pub use token::{
ExchangeRequest, MAX_TOKEN_LIFETIME_SECONDS, RefreshRequest, Token, authorization_url,
};
pub use transport::{DEFAULT_REQUEST_TIMEOUT, MAX_REQUEST_TIMEOUT};
#[derive(Clone)]
pub struct OAuthClient {
http: Arc<dyn HttpClient>,
request_timeout: Duration,
launchpad_issuer: String,
}
impl OAuthClient {
pub fn new(http: impl HttpClient + 'static) -> OAuthClient {
OAuthClient {
http: Arc::new(http),
request_timeout: DEFAULT_REQUEST_TIMEOUT,
launchpad_issuer: LAUNCHPAD_ISSUER.to_string(),
}
}
pub fn with_request_timeout(mut self, timeout: Duration) -> OAuthClient {
self.request_timeout = transport::normalize_timeout(timeout);
self
}
pub fn with_launchpad_issuer(mut self, issuer: impl Into<String>) -> OAuthClient {
self.launchpad_issuer = issuer.into();
self
}
pub fn request_timeout(&self) -> Duration {
self.request_timeout
}
pub fn launchpad_issuer(&self) -> &str {
&self.launchpad_issuer
}
pub(crate) fn http(&self) -> &dyn HttpClient {
self.http.as_ref()
}
}
impl fmt::Debug for OAuthClient {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("OAuthClient")
.field("request_timeout", &self.request_timeout)
.field("launchpad_issuer", &self.launchpad_issuer)
.finish_non_exhaustive()
}
}
#[cfg(feature = "reqwest")]
#[cfg_attr(docsrs, doc(cfg(feature = "reqwest")))]
impl OAuthClient {
pub fn shipped() -> Result<OAuthClient, crate::Error> {
let http = crate::http::ReqwestClient::with_timeout(MAX_REQUEST_TIMEOUT)?;
Ok(OAuthClient::new(http))
}
}
fn is_blank(secret: &SensitiveString) -> bool {
secret.is_empty()
}