Try to use generics and type annotations.

Author: G8XSU

rust/server/src/main.rs

@@ -18,8 +18,7 @@ use hyper::server::conn::http1;
 use hyper_util::rt::TokioIo;
 
 use crate::vss_service::VssService;
-use api::auth::{Authorizer, NoopAuthorizer};
-use api::kv_store::KvStore;
+use api::auth::NoopAuthorizer;
 use impls::postgres_store::PostgresBackendImpl;
 use std::sync::Arc;
 
@@ -59,7 +58,7 @@ fn main() {
 					match res {
 						Ok((stream, _)) => {
 							let io_stream = TokioIo::new(stream);
-							let vss_service = VssService::new(Arc::clone(&store) as Arc<dyn KvStore>, Arc::clone(&authorizer) as Arc<dyn Authorizer>);
+							let vss_service = VssService::new(Arc::clone(&store), Arc::clone(&authorizer));
 							runtime.spawn(async move {
 								if let Err(err) = http1::Builder::new().serve_connection(io_stream, vss_service).await {
 									eprintln!("Failed to serve connection: {}", err);

rust/server/src/vss_service.rs

@@ -19,18 +19,30 @@ use std::pin::Pin;
 use std::sync::Arc;
 
 #[derive(Clone)]
-pub struct VssService {
-	store: Arc<dyn KvStore>,
-	authorizer: Arc<dyn Authorizer>,
+pub struct VssService<K, A>
+where
+	K: KvStore,
+	A: Authorizer,
+{
+	store: Arc<K>,
+	authorizer: Arc<A>,
 }
 
-impl VssService {
-	pub(crate) fn new(store: Arc<dyn KvStore>, authorizer: Arc<dyn Authorizer>) -> Self {
+impl<K, A> VssService<K, A>
+where
+	K: KvStore,
+	A: Authorizer,
+{
+	pub(crate) fn new(store: Arc<K>, authorizer: Arc<A>) -> Self {
 		Self { store, authorizer }
 	}
 }
 
-impl Service<Request<Incoming>> for VssService {
+impl<K, A> Service<Request<Incoming>> for VssService<K, A>
+where
+	K: KvStore + 'static,
+	A: Authorizer + 'static,
+{
 	type Response = Response<Full<Bytes>>;
 	type Error = hyper::Error;
 	type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -65,35 +77,36 @@ impl Service<Request<Incoming>> for VssService {
 	}
 }
 
-async fn handle_get_object_request(
-	store: Arc<dyn KvStore>, user_token: String, request: GetObjectRequest,
+async fn handle_get_object_request<K: KvStore>(
+	store: Arc<K>, user_token: String, request: GetObjectRequest,
 ) -> Result<GetObjectResponse, VssError> {
 	store.get(user_token, request).await
 }
-async fn handle_put_object_request(
-	store: Arc<dyn KvStore>, user_token: String, request: PutObjectRequest,
+async fn handle_put_object_request<K: KvStore>(
+	store: Arc<K>, user_token: String, request: PutObjectRequest,
 ) -> Result<PutObjectResponse, VssError> {
 	store.put(user_token, request).await
 }
-async fn handle_delete_object_request(
-	store: Arc<dyn KvStore>, user_token: String, request: DeleteObjectRequest,
+async fn handle_delete_object_request<K: KvStore>(
+	store: Arc<K>, user_token: String, request: DeleteObjectRequest,
 ) -> Result<DeleteObjectResponse, VssError> {
 	store.delete(user_token, request).await
 }
-async fn handle_list_object_request(
-	store: Arc<dyn KvStore>, user_token: String, request: ListKeyVersionsRequest,
+async fn handle_list_object_request<K: KvStore>(
+	store: Arc<K>, user_token: String, request: ListKeyVersionsRequest,
 ) -> Result<ListKeyVersionsResponse, VssError> {
 	store.list_key_versions(user_token, request).await
 }
 async fn handle_request<
 	T: Message + Default,
 	R: Message,
-	F: FnOnce(Arc<dyn KvStore>, String, T) -> Fut + Send + 'static,
+	F: FnOnce(Arc<K>, String, T) -> Fut + Send,
 	Fut: Future<Output = Result<R, VssError>> + Send,
+	K: KvStore + 'static,
+	A: Authorizer + 'static,
 >(
-	store: Arc<dyn KvStore>, authorizer: Arc<dyn Authorizer>, request: Request<Incoming>,
-	handler: F,
-) -> Result<<VssService as Service<Request<Incoming>>>::Response, hyper::Error> {
+	store: Arc<K>, authorizer: Arc<A>, request: Request<Incoming>, handler: F,
+) -> Result<<VssService<K, A> as Service<Request<Incoming>>>::Response, hyper::Error> {
 	let (parts, body) = request.into_parts();
 	let headers_map = parts
 		.headers