Differential D8722 Diff 29802 services/identity/src/grpc_services/authenticated.rs

Changeset View

Standalone View

services/identity/src/grpc_services/authenticated.rs

use crate::{client_service::handle_db_error, database::DatabaseClient};		use crate::{client_service::handle_db_error, database::DatabaseClient};
use tonic::{Request, Response, Status};		use tonic::{Request, Response, Status};

// This must be named client, because generated code from the authenticated		// This must be named client, because generated code from the authenticated
// protobuf file references message structs from the client protobuf file		// protobuf file references message structs from the client protobuf file
// with the client:: namespace		// with the client:: namespace
pub mod client {		pub mod client {
tonic::include_proto!("identity.client");		tonic::include_proto!("identity.client");
}		}
pub mod auth_proto {		pub mod auth_proto {
tonic::include_proto!("identity.authenticated");		tonic::include_proto!("identity.authenticated");
}		}
use auth_proto::{		use auth_proto::{
identity_client_service_server::IdentityClientService, KeyserverKeysResponse,		identity_client_service_server::IdentityClientService, KeyserverKeysResponse,
OutboundKeysForUserRequest, RefreshUserPreKeysRequest,		OutboundKeyInfo, OutboundKeysForUserRequest, RefreshUserPreKeysRequest,
};		};
use client::Empty;		use client::{Empty, IdentityKeyInfo};
use tracing::debug;		use tracing::debug;

#[derive(derive_more::Constructor)]		#[derive(derive_more::Constructor)]
pub struct AuthenticatedService {		pub struct AuthenticatedService {
db_client: DatabaseClient,		db_client: DatabaseClient,
}		}

fn get_value<T>(req: &Request<T>, key: &str) -> Option<String> {		fn get_value<T>(req: &Request<T>, key: &str) -> Option<String> {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines	self
.map_err(handle_db_error)?;		.map_err(handle_db_error)?;

let response = Response::new(Empty {});		let response = Response::new(Empty {});
Ok(response)		Ok(response)
}		}

async fn get_keyserver_keys(		async fn get_keyserver_keys(
&self,		&self,
_request: Request<OutboundKeysForUserRequest>,		request: Request<OutboundKeysForUserRequest>,
) -> Result<Response<KeyserverKeysResponse>, Status> {		) -> Result<Response<KeyserverKeysResponse>, Status> {
unimplemented!();		let message = request.into_inner();

		let inner_response = self
		.db_client
		.get_keyserver_keys_for_user(&message.user_id)
		.await
		.map_err(handle_db_error)?
		.map(\|db_keys\| OutboundKeyInfo {
		identity_info: Some(IdentityKeyInfo {
		payload: db_keys.key_payload,
		payload_signature: db_keys.key_payload_signature,
		social_proof: db_keys.social_proof,
		}),
		content_prekey: Some(client::PreKey {
		pre_key: db_keys.content_prekey.prekey,
		pre_key_signature: db_keys.content_prekey.prekey_signature,
		}),
		notif_prekey: Some(client::PreKey {
		pre_key: db_keys.notif_prekey.prekey,
		pre_key_signature: db_keys.notif_prekey.prekey_signature,
		}),
		onetime_content_prekey: db_keys.content_one_time_key,
		onetime_notif_prekey: db_keys.notif_one_time_key,
		});

		let response = Response::new(KeyserverKeysResponse {
		keyserver_info: inner_response,
		});

		return Ok(response);
}		}
}		}