Crate for using OAuth 2.0 with Server to Server Applications for Google Cloud Engine, with tentative support for all supported Scopes. Supports sync or async requests via Futures.
Provides a serialisable Token struct for use in other applications that require authenticated interactions with Google Cloud.
```rust,no_run
extern crate log;
use goauth::auth::JwtClaims; use goauth::scopes::Scope; use goauth::{gettoken, gettokenblocking, GoErr}; use goauth::credentials::Credentials; use goauth::fetcher::TokenFetcher; use smpljwt::{RSAKey, Jwt}; use time::Duration;
fn main() -> Result<(), GoErr>{
let token_url = "https://www.googleapis.com/oauth2/v4/token";
let iss = "
let credentials = Credentials::fromfile("dummycredentialsfilefortests.json").unwrap(); let claims = JwtClaims::new(String::from(iss), &Scope::DevStorageReadWrite, String::from(tokenurl), None, None); let jwt = Jwt::new(claims, credentials.rsa_key().unwrap(), None);
// Use async let token = async { match get_token(&jwt, &credentials).await { Ok(token) => token, Err(e) => panic!(e) } };
// Or sync let token = gettokenblocking(&jwt, &credentials)?;
// Token provides access_token method that outputs a value that should be placed in the Authorization header
// Or use the TokenFetcher abstraction which will automatically refresh tokens let fetcher = TokenFetcher::new(jwt, credentials, Duration::new(1, 0));
let token = async { match fetcher.fetch_token().await { Ok(token) => token, Err(e) => panic!(e) } };
// Now a couple seconds later we want the token again - the initial token is cached so it will re-use // the same token, saving a network trip to fetch another token let newtoken = async { match fetcher.fetchtoken().await { Ok(token) => token, Err(e) => panic!(e) } };
asserteq!(token, newtoken);
// Now say the token has expired or is close to expiring ("close" defined by the configurable
// refresh_buffer parameter) at this point "later in the program." The next call to
// fetch_token will notice this and automatically fetch a new token, cache it, and return it.
let newtoken = async {
match fetcher.fetchtoken().await {
Ok(token) => token,
Err(e) => panic!(e)
}
};
assertne!(token, newtoken);
Ok(()) } ```