···

       
204
       
 
       
    }

     

       
205
       
 
       


     

       
206
       
 
       
    async fn create_session(&self, data: ClientSessionData<'_>) -> Result<OAuthSession<T, S>> {

     

       
0
       
 
       

     

       
207
       
 
       
        Ok(OAuthSession::new(

     

       
208
       
 
       
            self.registry.clone(),

     

       
209
       
 
       
            self.client.clone(),

     
···

       
336
       
 
       
        let refreshed = self.registry.as_ref().get(&did, &sid, true).await?;

     

       
337
       
 
       
        let token = AuthorizationToken::Dpop(refreshed.token_set.access_token.clone());

     

       
338
       
 
       
        // Write back updated session

     

       
339
       
-
       
        *self.data.write().await = refreshed.into_static();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
340
       
 
       
        Ok(token)

     

       
341
       
 
       
    }

     

       
342
       
 
       
}

     
···

       
390
       
 
       
            .send(build_http_request(&base_uri, request, &opts)?)

     

       
391
       
 
       
            .await

     

       
392
       
 
       
            .map_err(|e| TransportError::Other(Box::new(e)))?;

     

       
0
       
 
       

     

       
393
       
 
       
        let res = process_response(http_response);

     

       
394
       
 
       
        if is_invalid_token_response(&res) {

     

       
395
       
 
       
            opts.auth = Some(

     
···

       
397
       
 
       
                    .await

     

       
398
       
 
       
                    .map_err(|e| ClientError::Transport(TransportError::Other(e.into())))?,

     

       
399
       
 
       
            );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
400
       
 
       
            let http_response = self

     

       
401
       
 
       
                .client

     

       
402
       
 
       
                .dpop_call(&mut dpop)

     

···

       
204
       
 
       
    }

     

       
205
       
 
       


     

       
206
       
 
       
    async fn create_session(&self, data: ClientSessionData<'_>) -> Result<OAuthSession<T, S>> {

     

       
207
       
+
       
        self.registry.set(data.clone()).await?;

     

       
208
       
 
       
        Ok(OAuthSession::new(

     

       
209
       
 
       
            self.registry.clone(),

     

       
210
       
 
       
            self.client.clone(),

     
···

       
337
       
 
       
        let refreshed = self.registry.as_ref().get(&did, &sid, true).await?;

     

       
338
       
 
       
        let token = AuthorizationToken::Dpop(refreshed.token_set.access_token.clone());

     

       
339
       
 
       
        // Write back updated session

     

       
340
       
+
       
        *self.data.write().await = refreshed.clone().into_static();

     

       
341
       
+
       
        // Store in the registry

     

       
342
       
+
       
        self.registry.set(refreshed).await?;

     

       
343
       
 
       
        Ok(token)

     

       
344
       
 
       
    }

     

       
345
       
 
       
}

     
···

       
393
       
 
       
            .send(build_http_request(&base_uri, request, &opts)?)

     

       
394
       
 
       
            .await

     

       
395
       
 
       
            .map_err(|e| TransportError::Other(Box::new(e)))?;

     

       
396
       
+
       
        drop(guard);

     

       
397
       
 
       
        let res = process_response(http_response);

     

       
398
       
 
       
        if is_invalid_token_response(&res) {

     

       
399
       
 
       
            opts.auth = Some(

     
···

       
401
       
 
       
                    .await

     

       
402
       
 
       
                    .map_err(|e| ClientError::Transport(TransportError::Other(e.into())))?,

     

       
403
       
 
       
            );

     

       
404
       
+
       
            let guard = self.data.read().await;

     

       
405
       
+
       
            let mut dpop = guard.dpop_data.clone();

     

       
406
       
 
       
            let http_response = self

     

       
407
       
 
       
                .client

     

       
408
       
 
       
                .dpop_call(&mut dpop)