Update error code change

Author: sitaowang1998

components/spider-execution-manager/src/client/grpc/liveness.rs

@@ -6,9 +6,9 @@ use async_trait::async_trait;
 use spider_core::types::id::{ExecutionManagerId, SessionId};
 use spider_proto_rust::storage::{
     self,
+    execution_manager_liveness_error,
     execution_manager_liveness_service_client::ExecutionManagerLivenessServiceClient,
     register_execution_manager_response,
-    storage_error,
     update_execution_manager_heartbeat_response,
 };
 use tonic::transport::{Channel, Endpoint};
@@ -125,19 +125,23 @@ fn heartbeat_response_to_result(
 /// # Returns
 ///
 /// The corresponding [`LivenessResponseError`].
-fn storage_error_to_liveness_error(error: storage::StorageError) -> LivenessResponseError {
-    match storage_error::ErrCode::try_from(error.err_code) {
-        Ok(storage_error::ErrCode::CacheStale) => LivenessResponseError::MarkedDead,
-        Ok(storage_error::ErrCode::InvalidInput) => LivenessResponseError::IllegalId(error.message),
+fn storage_error_to_liveness_error(
+    error: storage::ExecutionManagerLivenessError,
+) -> LivenessResponseError {
+    match execution_manager_liveness_error::ErrCode::try_from(error.err_code) {
+        Ok(execution_manager_liveness_error::ErrCode::MarkedDead) => {
+            LivenessResponseError::MarkedDead
+        }
+        Ok(execution_manager_liveness_error::ErrCode::InvalidInput) => {
+            LivenessResponseError::IllegalId(error.message)
+        }
         Ok(
-            storage_error::ErrCode::Transport
-            | storage_error::ErrCode::Server
-            | storage_error::ErrCode::StaleSession
-            | storage_error::ErrCode::Unspecified,
+            execution_manager_liveness_error::ErrCode::Server
+            | execution_manager_liveness_error::ErrCode::Unspecified,
         ) => LivenessResponseError::Transport(error.message),
-        Err(error) => {
-            LivenessResponseError::Transport(format!("unknown storage error kind: {error}"))
-        }
+        Err(error) => LivenessResponseError::Transport(format!(
+            "unknown execution manager liveness error kind: {error}"
+        )),
     }
 }
 
@@ -194,10 +198,9 @@ mod tests {
 
     #[test]
     fn liveness_storage_error_maps_invalid_input_to_illegal_id() {
-        let error = storage::StorageError {
-            err_code: storage_error::ErrCode::InvalidInput.into(),
+        let error = storage::ExecutionManagerLivenessError {
+            err_code: execution_manager_liveness_error::ErrCode::InvalidInput.into(),
             message: "bad em id".to_owned(),
-            storage_session: 0,
         };
 
         match storage_error_to_liveness_error(error) {

components/spider-execution-manager/src/client/grpc/storage.rs

@@ -11,9 +11,9 @@ use spider_core::types::{
 use spider_proto_rust::storage::{
     self,
     register_task_instance_response,
-    storage_error,
-    storage_operation_response,
+    task_instance_error,
     task_instance_management_service_client::TaskInstanceManagementServiceClient,
+    task_instance_operation_response,
 };
 use tonic::transport::{Channel, Endpoint};
 
@@ -136,32 +136,32 @@ impl StorageClient for GrpcStorageClient {
     }
 }
 
-impl From<storage::StorageError> for StorageResponseError {
-    fn from(error: storage::StorageError) -> Self {
-        match storage_error::ErrCode::try_from(error.err_code) {
-            Ok(storage_error::ErrCode::StaleSession) => Self::StaleSession {
+impl From<storage::TaskInstanceError> for StorageResponseError {
+    fn from(error: storage::TaskInstanceError) -> Self {
+        match task_instance_error::ErrCode::try_from(error.err_code) {
+            Ok(task_instance_error::ErrCode::StaleSession) => Self::StaleSession {
                 storage_session: error.storage_session,
             },
-            Ok(storage_error::ErrCode::CacheStale) => Self::CacheStale(error.message),
-            Ok(storage_error::ErrCode::Transport) => Self::Transport(error.message),
-            Ok(storage_error::ErrCode::Server | storage_error::ErrCode::Unspecified) => {
-                Self::Server(error.message)
-            }
-            Ok(storage_error::ErrCode::InvalidInput) => Self::InvalidInput(error.message),
-            Err(error) => Self::Transport(format!("unknown storage error kind: {error}")),
+            Ok(task_instance_error::ErrCode::CacheStale) => Self::CacheStale(error.message),
+            Ok(
+                task_instance_error::ErrCode::Server | task_instance_error::ErrCode::Unspecified,
+            ) => Self::Server(error.message),
+            Ok(task_instance_error::ErrCode::InvalidInput) => Self::InvalidInput(error.message),
+            Err(error) => Self::Transport(format!("unknown task instance error kind: {error}")),
         }
     }
 }
 
 /// # Returns
 ///
-/// [`storage::StorageOperationResponse`] converted into [`Result<(), StorageResponseError>`].
+/// [`storage::TaskInstanceOperationResponse`] converted into
+/// [`Result<(), StorageResponseError>`].
 fn storage_operation_response_to_result(
-    response: storage::StorageOperationResponse,
+    response: storage::TaskInstanceOperationResponse,
 ) -> Result<(), StorageResponseError> {
     match response.result {
-        Some(storage_operation_response::Result::Ok(_)) => Ok(()),
-        Some(storage_operation_response::Result::Error(error)) => Err(error.into()),
+        Some(task_instance_operation_response::Result::Ok(_)) => Ok(()),
+        Some(task_instance_operation_response::Result::Error(error)) => Err(error.into()),
         None => Err(StorageResponseError::Transport(
             "storage operation response missing `result` message".to_owned(),
         )),
@@ -183,8 +183,8 @@ mod tests {
 
     #[test]
     fn storage_error_maps_stale_session() {
-        let error = storage::StorageError {
-            err_code: storage_error::ErrCode::StaleSession.into(),
+        let error = storage::TaskInstanceError {
+            err_code: task_instance_error::ErrCode::StaleSession.into(),
             message: "stale".to_owned(),
             storage_session: 7,
         };
@@ -199,23 +199,23 @@ mod tests {
 
     #[test]
     fn storage_error_maps_unknown_kind_to_transport_error() {
-        let error = storage::StorageError {
+        let error = storage::TaskInstanceError {
             err_code: 99,
             message: "unknown".to_owned(),
             storage_session: 0,
         };
 
         match StorageResponseError::from(error) {
             StorageResponseError::Transport(message) => {
-                assert!(message.contains("unknown storage error kind"));
+                assert!(message.contains("unknown task instance error kind"));
             }
             error => panic!("unexpected storage response error: {error:?}"),
         }
     }
 
     #[test]
     fn missing_storage_operation_result_is_transport_error() {
-        match storage_operation_response_to_result(storage::StorageOperationResponse {
+        match storage_operation_response_to_result(storage::TaskInstanceOperationResponse {
             result: None,
         }) {
             Err(StorageResponseError::Transport(_)) => {}