diff --git a/agent/src/plugin_manager/v1.rs b/agent/src/plugin_manager/v1.rs
index f016fb20b..7f3183f3f 100644
--- a/agent/src/plugin_manager/v1.rs
+++ b/agent/src/plugin_manager/v1.rs
@@ -87,8 +87,8 @@ pub struct NumaNode {
 /// Generated client implementations.
 pub mod pod_resources_lister_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     /// PodResourcesLister is a service provided by the kubelet that provides information about the
     /// node resources consumed by pods and containers on the node
     #[derive(Debug, Clone)]
@@ -134,9 +134,8 @@ pub mod pod_resources_lister_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
         {
             PodResourcesListerClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -174,23 +173,16 @@ pub mod pod_resources_lister_client {
         pub async fn list(
             &mut self,
             request: impl tonic::IntoRequest<super::ListPodResourcesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ListPodResourcesResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::ListPodResourcesResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/v1.PodResourcesLister/List",
-            );
+            let path = http::uri::PathAndQuery::from_static("/v1.PodResourcesLister/List");
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("v1.PodResourcesLister", "List"));
@@ -199,28 +191,23 @@ pub mod pod_resources_lister_client {
         pub async fn get_allocatable_resources(
             &mut self,
             request: impl tonic::IntoRequest<super::AllocatableResourcesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AllocatableResourcesResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::AllocatableResourcesResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/v1.PodResourcesLister/GetAllocatableResources",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("v1.PodResourcesLister", "GetAllocatableResources"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "v1.PodResourcesLister",
+                "GetAllocatableResources",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
@@ -235,17 +222,11 @@ pub mod pod_resources_lister_server {
         async fn list(
             &self,
             request: tonic::Request<super::ListPodResourcesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ListPodResourcesResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::ListPodResourcesResponse>, tonic::Status>;
         async fn get_allocatable_resources(
             &self,
             request: tonic::Request<super::AllocatableResourcesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AllocatableResourcesResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::AllocatableResourcesResponse>, tonic::Status>;
     }
     /// PodResourcesLister is a service provided by the kubelet that provides information about the
     /// node resources consumed by pods and containers on the node
@@ -272,10 +253,7 @@ pub mod pod_resources_lister_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -331,15 +309,11 @@ pub mod pod_resources_lister_server {
                 "/v1.PodResourcesLister/List" => {
                     #[allow(non_camel_case_types)]
                     struct ListSvc<T: PodResourcesLister>(pub Arc<T>);
-                    impl<
-                        T: PodResourcesLister,
-                    > tonic::server::UnaryService<super::ListPodResourcesRequest>
-                    for ListSvc<T> {
+                    impl<T: PodResourcesLister>
+                        tonic::server::UnaryService<super::ListPodResourcesRequest> for ListSvc<T>
+                    {
                         type Response = super::ListPodResourcesResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListPodResourcesRequest>,
@@ -377,15 +351,12 @@ pub mod pod_resources_lister_server {
                 "/v1.PodResourcesLister/GetAllocatableResources" => {
                     #[allow(non_camel_case_types)]
                     struct GetAllocatableResourcesSvc<T: PodResourcesLister>(pub Arc<T>);
-                    impl<
-                        T: PodResourcesLister,
-                    > tonic::server::UnaryService<super::AllocatableResourcesRequest>
-                    for GetAllocatableResourcesSvc<T> {
+                    impl<T: PodResourcesLister>
+                        tonic::server::UnaryService<super::AllocatableResourcesRequest>
+                        for GetAllocatableResourcesSvc<T>
+                    {
                         type Response = super::AllocatableResourcesResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AllocatableResourcesRequest>,
@@ -393,10 +364,9 @@ pub mod pod_resources_lister_server {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as PodResourcesLister>::get_allocatable_resources(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -424,18 +394,14 @@ pub mod pod_resources_lister_server {
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
+                _ => Box::pin(async move {
+                    Ok(http::Response::builder()
+                        .status(200)
+                        .header("grpc-status", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
             }
         }
     }
@@ -461,8 +427,7 @@ pub mod pod_resources_lister_server {
             write!(f, "{:?}", self.0)
         }
     }
-    impl<T: PodResourcesLister> tonic::server::NamedService
-    for PodResourcesListerServer<T> {
+    impl<T: PodResourcesLister> tonic::server::NamedService for PodResourcesListerServer<T> {
         const NAME: &'static str = "v1.PodResourcesLister";
     }
 }
diff --git a/agent/src/plugin_manager/v1beta1.rs b/agent/src/plugin_manager/v1beta1.rs
index 7b068ecab..a88570f4d 100644
--- a/agent/src/plugin_manager/v1beta1.rs
+++ b/agent/src/plugin_manager/v1beta1.rs
@@ -96,9 +96,7 @@ pub struct PreStartContainerResponse {}
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct PreferredAllocationRequest {
     #[prost(message, repeated, tag = "1")]
-    pub container_requests: ::prost::alloc::vec::Vec<
-        ContainerPreferredAllocationRequest,
-    >,
+    pub container_requests: ::prost::alloc::vec::Vec<ContainerPreferredAllocationRequest>,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -108,9 +106,7 @@ pub struct ContainerPreferredAllocationRequest {
     pub available_device_i_ds: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
     /// List of deviceIDs that must be included in the preferred allocation
     #[prost(string, repeated, tag = "2")]
-    pub must_include_device_i_ds: ::prost::alloc::vec::Vec<
-        ::prost::alloc::string::String,
-    >,
+    pub must_include_device_i_ds: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
     /// Number of devices to include in the preferred allocation
     #[prost(int32, tag = "3")]
     pub allocation_size: i32,
@@ -121,9 +117,7 @@ pub struct ContainerPreferredAllocationRequest {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct PreferredAllocationResponse {
     #[prost(message, repeated, tag = "1")]
-    pub container_responses: ::prost::alloc::vec::Vec<
-        ContainerPreferredAllocationResponse,
-    >,
+    pub container_responses: ::prost::alloc::vec::Vec<ContainerPreferredAllocationResponse>,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -168,10 +162,8 @@ pub struct AllocateResponse {
 pub struct ContainerAllocateResponse {
     /// List of environment variable to be set in the container to access one of more devices.
     #[prost(map = "string, string", tag = "1")]
-    pub envs: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
-    >,
+    pub envs:
+        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
     /// Mounts for the container.
     #[prost(message, repeated, tag = "2")]
     pub mounts: ::prost::alloc::vec::Vec<Mount>,
@@ -180,10 +172,8 @@ pub struct ContainerAllocateResponse {
     pub devices: ::prost::alloc::vec::Vec<DeviceSpec>,
     /// Container annotations to pass to the container runtime
     #[prost(map = "string, string", tag = "4")]
-    pub annotations: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
-    >,
+    pub annotations:
+        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
 }
 /// Mount specifies a host volume to mount into a container.
 /// where device library or tools are installed on host and container
@@ -220,8 +210,8 @@ pub struct DeviceSpec {
 /// Generated client implementations.
 pub mod registration_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     /// Registration is the service advertised by the Kubelet
     /// Only when Kubelet answers with a success code to a Register Request
     /// may Device Plugins start their service
@@ -271,9 +261,8 @@ pub mod registration_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
         {
             RegistrationClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -312,19 +301,14 @@ pub mod registration_client {
             &mut self,
             request: impl tonic::IntoRequest<super::RegisterRequest>,
         ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/v1beta1.Registration/Register",
-            );
+            let path = http::uri::PathAndQuery::from_static("/v1beta1.Registration/Register");
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("v1beta1.Registration", "Register"));
@@ -335,8 +319,8 @@ pub mod registration_client {
 /// Generated client implementations.
 pub mod device_plugin_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     /// DevicePlugin is the service advertised by Device Plugins
     #[derive(Debug, Clone)]
     pub struct DevicePluginClient<T> {
@@ -381,9 +365,8 @@ pub mod device_plugin_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
         {
             DevicePluginClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -423,28 +406,23 @@ pub mod device_plugin_client {
         pub async fn get_device_plugin_options(
             &mut self,
             request: impl tonic::IntoRequest<super::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::DevicePluginOptions>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::DevicePluginOptions>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/v1beta1.DevicePlugin/GetDevicePluginOptions",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("v1beta1.DevicePlugin", "GetDevicePluginOptions"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "v1beta1.DevicePlugin",
+                "GetDevicePluginOptions",
+            ));
             self.inner.unary(req, path, codec).await
         }
         /// ListAndWatch returns a stream of List of Devices
@@ -457,19 +435,14 @@ pub mod device_plugin_client {
             tonic::Response<tonic::codec::Streaming<super::ListAndWatchResponse>>,
             tonic::Status,
         > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/v1beta1.DevicePlugin/ListAndWatch",
-            );
+            let path = http::uri::PathAndQuery::from_static("/v1beta1.DevicePlugin/ListAndWatch");
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("v1beta1.DevicePlugin", "ListAndWatch"));
@@ -483,28 +456,23 @@ pub mod device_plugin_client {
         pub async fn get_preferred_allocation(
             &mut self,
             request: impl tonic::IntoRequest<super::PreferredAllocationRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreferredAllocationResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PreferredAllocationResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/v1beta1.DevicePlugin/GetPreferredAllocation",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("v1beta1.DevicePlugin", "GetPreferredAllocation"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "v1beta1.DevicePlugin",
+                "GetPreferredAllocation",
+            ));
             self.inner.unary(req, path, codec).await
         }
         /// Allocate is called during container creation so that the Device
@@ -513,23 +481,15 @@ pub mod device_plugin_client {
         pub async fn allocate(
             &mut self,
             request: impl tonic::IntoRequest<super::AllocateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AllocateResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::AllocateResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/v1beta1.DevicePlugin/Allocate",
-            );
+            let path = http::uri::PathAndQuery::from_static("/v1beta1.DevicePlugin/Allocate");
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("v1beta1.DevicePlugin", "Allocate"));
@@ -541,23 +501,17 @@ pub mod device_plugin_client {
         pub async fn pre_start_container(
             &mut self,
             request: impl tonic::IntoRequest<super::PreStartContainerRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreStartContainerResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PreStartContainerResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/v1beta1.DevicePlugin/PreStartContainer",
-            );
+            let path =
+                http::uri::PathAndQuery::from_static("/v1beta1.DevicePlugin/PreStartContainer");
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("v1beta1.DevicePlugin", "PreStartContainer"));
@@ -606,10 +560,7 @@ pub mod registration_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -665,23 +616,16 @@ pub mod registration_server {
                 "/v1beta1.Registration/Register" => {
                     #[allow(non_camel_case_types)]
                     struct RegisterSvc<T: Registration>(pub Arc<T>);
-                    impl<
-                        T: Registration,
-                    > tonic::server::UnaryService<super::RegisterRequest>
-                    for RegisterSvc<T> {
+                    impl<T: Registration> tonic::server::UnaryService<super::RegisterRequest> for RegisterSvc<T> {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::RegisterRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Registration>::register(&inner, request).await
-                            };
+                            let fut =
+                                async move { <T as Registration>::register(&inner, request).await };
                             Box::pin(fut)
                         }
                     }
@@ -708,18 +652,14 @@ pub mod registration_server {
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
+                _ => Box::pin(async move {
+                    Ok(http::Response::builder()
+                        .status(200)
+                        .header("grpc-status", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
             }
         }
     }
@@ -761,15 +701,11 @@ pub mod device_plugin_server {
         async fn get_device_plugin_options(
             &self,
             request: tonic::Request<super::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::DevicePluginOptions>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::DevicePluginOptions>, tonic::Status>;
         /// Server streaming response type for the ListAndWatch method.
         type ListAndWatchStream: tonic::codegen::tokio_stream::Stream<
                 Item = std::result::Result<super::ListAndWatchResponse, tonic::Status>,
-            >
-            + Send
+            > + Send
             + 'static;
         /// ListAndWatch returns a stream of List of Devices
         /// Whenever a Device state change or a Device disappears, ListAndWatch
@@ -777,10 +713,7 @@ pub mod device_plugin_server {
         async fn list_and_watch(
             &self,
             request: tonic::Request<super::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<Self::ListAndWatchStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::ListAndWatchStream>, tonic::Status>;
         /// GetPreferredAllocation returns a preferred set of devices to allocate
         /// from a list of available ones. The resulting preferred allocation is not
         /// guaranteed to be the allocation ultimately performed by the
@@ -789,30 +722,21 @@ pub mod device_plugin_server {
         async fn get_preferred_allocation(
             &self,
             request: tonic::Request<super::PreferredAllocationRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreferredAllocationResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PreferredAllocationResponse>, tonic::Status>;
         /// Allocate is called during container creation so that the Device
         /// Plugin can run device specific operations and instruct Kubelet
         /// of the steps to make the Device available in the container
         async fn allocate(
             &self,
             request: tonic::Request<super::AllocateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AllocateResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::AllocateResponse>, tonic::Status>;
         /// PreStartContainer is called, if indicated by Device Plugin during registeration phase,
         /// before each container start. Device plugin can run device specific operations
         /// such as resetting the device before making devices available to the container
         async fn pre_start_container(
             &self,
             request: tonic::Request<super::PreStartContainerRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreStartContainerResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PreStartContainerResponse>, tonic::Status>;
     }
     /// DevicePlugin is the service advertised by Device Plugins
     #[derive(Debug)]
@@ -838,10 +762,7 @@ pub mod device_plugin_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -897,23 +818,13 @@ pub mod device_plugin_server {
                 "/v1beta1.DevicePlugin/GetDevicePluginOptions" => {
                     #[allow(non_camel_case_types)]
                     struct GetDevicePluginOptionsSvc<T: DevicePlugin>(pub Arc<T>);
-                    impl<T: DevicePlugin> tonic::server::UnaryService<super::Empty>
-                    for GetDevicePluginOptionsSvc<T> {
+                    impl<T: DevicePlugin> tonic::server::UnaryService<super::Empty> for GetDevicePluginOptionsSvc<T> {
                         type Response = super::DevicePluginOptions;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::Empty>,
-                        ) -> Self::Future {
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::Empty>) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DevicePlugin>::get_device_plugin_options(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as DevicePlugin>::get_device_plugin_options(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -945,20 +856,12 @@ pub mod device_plugin_server {
                 "/v1beta1.DevicePlugin/ListAndWatch" => {
                     #[allow(non_camel_case_types)]
                     struct ListAndWatchSvc<T: DevicePlugin>(pub Arc<T>);
-                    impl<
-                        T: DevicePlugin,
-                    > tonic::server::ServerStreamingService<super::Empty>
-                    for ListAndWatchSvc<T> {
+                    impl<T: DevicePlugin> tonic::server::ServerStreamingService<super::Empty> for ListAndWatchSvc<T> {
                         type Response = super::ListAndWatchResponse;
                         type ResponseStream = T::ListAndWatchStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::Empty>,
-                        ) -> Self::Future {
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::Empty>) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as DevicePlugin>::list_and_watch(&inner, request).await
@@ -992,26 +895,19 @@ pub mod device_plugin_server {
                 "/v1beta1.DevicePlugin/GetPreferredAllocation" => {
                     #[allow(non_camel_case_types)]
                     struct GetPreferredAllocationSvc<T: DevicePlugin>(pub Arc<T>);
-                    impl<
-                        T: DevicePlugin,
-                    > tonic::server::UnaryService<super::PreferredAllocationRequest>
-                    for GetPreferredAllocationSvc<T> {
+                    impl<T: DevicePlugin>
+                        tonic::server::UnaryService<super::PreferredAllocationRequest>
+                        for GetPreferredAllocationSvc<T>
+                    {
                         type Response = super::PreferredAllocationResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PreferredAllocationRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DevicePlugin>::get_preferred_allocation(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as DevicePlugin>::get_preferred_allocation(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -1042,23 +938,16 @@ pub mod device_plugin_server {
                 "/v1beta1.DevicePlugin/Allocate" => {
                     #[allow(non_camel_case_types)]
                     struct AllocateSvc<T: DevicePlugin>(pub Arc<T>);
-                    impl<
-                        T: DevicePlugin,
-                    > tonic::server::UnaryService<super::AllocateRequest>
-                    for AllocateSvc<T> {
+                    impl<T: DevicePlugin> tonic::server::UnaryService<super::AllocateRequest> for AllocateSvc<T> {
                         type Response = super::AllocateResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AllocateRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as DevicePlugin>::allocate(&inner, request).await
-                            };
+                            let fut =
+                                async move { <T as DevicePlugin>::allocate(&inner, request).await };
                             Box::pin(fut)
                         }
                     }
@@ -1088,23 +977,19 @@ pub mod device_plugin_server {
                 "/v1beta1.DevicePlugin/PreStartContainer" => {
                     #[allow(non_camel_case_types)]
                     struct PreStartContainerSvc<T: DevicePlugin>(pub Arc<T>);
-                    impl<
-                        T: DevicePlugin,
-                    > tonic::server::UnaryService<super::PreStartContainerRequest>
-                    for PreStartContainerSvc<T> {
+                    impl<T: DevicePlugin>
+                        tonic::server::UnaryService<super::PreStartContainerRequest>
+                        for PreStartContainerSvc<T>
+                    {
                         type Response = super::PreStartContainerResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PreStartContainerRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DevicePlugin>::pre_start_container(&inner, request)
-                                    .await
+                                <T as DevicePlugin>::pre_start_container(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -1132,18 +1017,14 @@ pub mod device_plugin_server {
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
+                _ => Box::pin(async move {
+                    Ok(http::Response::builder()
+                        .status(200)
+                        .header("grpc-status", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
             }
         }
     }
diff --git a/controller/Cargo.toml b/controller/Cargo.toml
index 993899b1c..fc063ac76 100644
--- a/controller/Cargo.toml
+++ b/controller/Cargo.toml
@@ -1,6 +1,5 @@
 [package]
 name = "controller"
-<<<<<<< HEAD
 authors.workspace = true
 version.workspace = true
 edition.workspace = true
@@ -8,15 +7,6 @@ license.workspace = true
 homepage.workspace = true
 repository.workspace = true
 rust-version.workspace = true
-=======
-version = "0.13.1"
-license = "Apache-2.0"
-authors = ["<bfjelds@microsoft.com>", "<kagold@microsoft.com>"]
-edition = "2021"
-rust-version = "1.75.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
->>>>>>> 1aada19 (Use ResourceExt methods for resource property access and update rust version to 1.75.0)
 
 [dependencies]
 akri-shared = { path = "../shared" }