This is an automated email from the ASF dual-hosted git repository.
mssun pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/incubator-teaclave.git
The following commit(s) were added to refs/heads/develop by this push:
new 6b91c73 [tests] Add End-to-End echo function test (#253)
6b91c73 is described below
commit 6b91c734605850c9af9dedd8aa918306b8b09f2d
Author: Zhaofeng Chen <[email protected]>
AuthorDate: Fri Mar 27 14:00:00 2020 -0700
[tests] Add End-to-End echo function test (#253)
---
cmake/scripts/test.sh | 2 +
services/execution/enclave/src/service.rs | 19 ++--
services/management/enclave/src/service.rs | 16 +++
.../src/proto/teaclave_frontend_service.proto | 4 +-
services/proto/src/teaclave_frontend_service.rs | 6 +
tests/functional/enclave/src/end_to_end.rs | 121 +++++++++++++++++++++
tests/functional/enclave/src/lib.rs | 2 +
types/src/task.rs | 2 +-
8 files changed, 160 insertions(+), 12 deletions(-)
diff --git a/cmake/scripts/test.sh b/cmake/scripts/test.sh
index c9ef7e8..a4ee77a 100755
--- a/cmake/scripts/test.sh
+++ b/cmake/scripts/test.sh
@@ -97,6 +97,8 @@ run_functional_tests() {
./teaclave_functional_tests -t execution_service
+ ./teaclave_functional_tests -t end_to_end
+
# Run script tests
./scripts/functional_tests.py -v
diff --git a/services/execution/enclave/src/service.rs
b/services/execution/enclave/src/service.rs
index 86fa19b..829a7c9 100644
--- a/services/execution/enclave/src/service.rs
+++ b/services/execution/enclave/src/service.rs
@@ -27,7 +27,6 @@ use teaclave_types::{ExecutionResult, StagedFunction,
StagedTask, TaskStatus};
use teaclave_worker::Worker;
use anyhow::Result;
-use log::debug;
use uuid::Uuid;
#[derive(Clone)]
@@ -64,7 +63,7 @@ impl TeaclaveExecutionService {
let mut client = match scheduler_client.lock() {
Ok(client) => client,
Err(e) => {
- log::error!("Error: {:?}", e);
+ log::error!("Start Error: {:?}", e);
continue;
}
};
@@ -74,7 +73,7 @@ impl TeaclaveExecutionService {
let response = match client.pull_task(request) {
Ok(response) => response,
Err(e) => {
- log::error!("Error: {:?}", e);
+ log::error!("PullTask Error: {:?}", e);
continue;
}
};
@@ -83,18 +82,18 @@ impl TeaclaveExecutionService {
log::debug!("response: {:?}", response);
let staged_task = response.staged_task;
let result = self.invoke_task(&staged_task).unwrap();
- debug!("result: {:?}", result);
+ log::debug!("result: {:?}", result);
match self.update_task_status(&staged_task.task_id,
TaskStatus::Finished) {
Ok(_) => (),
Err(e) => {
- log::error!("Error: {:?}", e);
+ log::error!("UpdateTask Error: {:?}", e);
continue;
}
}
match self.update_task_result(&staged_task.task_id, result) {
Ok(_) => (),
Err(e) => {
- log::error!("Error: {:?}", e);
+ log::error!("UpdateResult Error: {:?}", e);
continue;
}
}
@@ -102,12 +101,12 @@ impl TeaclaveExecutionService {
}
fn invoke_task(&mut self, task: &StagedTask) -> Result<ExecutionResult> {
- debug!("invoke_task");
+ log::debug!("invoke_task");
self.update_task_status(&task.task_id, TaskStatus::Running)?;
let invocation = prepare_task(&task);
let worker = Worker::default();
let summary = worker.invoke_function(invocation)?;
- debug!("summary: {:?}", summary);
+ log::debug!("summary: {:?}", summary);
finalize_task(&task)?;
let mut result = ExecutionResult::default();
result.return_value = summary.as_bytes().to_vec();
@@ -116,7 +115,7 @@ impl TeaclaveExecutionService {
}
fn update_task_result(&mut self, task_id: &Uuid, result: ExecutionResult)
-> Result<()> {
- debug!("update_task_result");
+ log::debug!("update_task_result");
let request = UpdateTaskResultRequest::new(
task_id.to_owned(),
&result.return_value,
@@ -133,7 +132,7 @@ impl TeaclaveExecutionService {
}
fn update_task_status(&mut self, task_id: &Uuid, task_status: TaskStatus)
-> Result<()> {
- debug!("update_task_status");
+ log::debug!("update_task_status");
let request = UpdateTaskStatusRequest::new(task_id.to_owned(),
task_status);
let _response = self
.scheduler_client
diff --git a/services/management/enclave/src/service.rs
b/services/management/enclave/src/service.rs
index 081b9a3..425a71d 100644
--- a/services/management/enclave/src/service.rs
+++ b/services/management/enclave/src/service.rs
@@ -343,6 +343,9 @@ impl TeaclaveManagement for TeaclaveManagementService {
request.output_data_owner_list,
)
.map_err(|_| TeaclaveManagementError::BadTask)?;
+
+ log::info!("CreateTask: {:?}", task);
+
self.write_to_db(&task)
.map_err(|_| TeaclaveManagementError::StorageError)?;
Ok(CreateTaskResponse {
@@ -384,6 +387,8 @@ impl TeaclaveManagement for TeaclaveManagementService {
approved_user_list: task.approved_user_list,
input_map: task.input_map,
output_map: task.output_map,
+ return_value: task.return_value,
+ output_file_hash: task.output_file_hash,
status: task.status,
};
Ok(response)
@@ -484,6 +489,9 @@ impl TeaclaveManagement for TeaclaveManagementService {
}
task.approved_user_list.insert(user_id);
try_update_task_to_approved_status(&mut task);
+
+ log::info!("ApproveTask: try approve:{:?}", task);
+
self.write_to_db(&task)
.map_err(|_| TeaclaveManagementError::StorageError)?;
Ok(ApproveTaskResponse)
@@ -506,10 +514,13 @@ impl TeaclaveManagement for TeaclaveManagementService {
Task::match_prefix(&request.task_id),
TeaclaveManagementError::PermissionDenied
);
+
let mut task: Task = self
.read_from_db(request.task_id.as_bytes())
.map_err(|_| TeaclaveManagementError::PermissionDenied)?;
+ log::info!("InvokeTask: get task: {:?}", task);
+
ensure!(
task.creator == user_id,
TeaclaveManagementError::PermissionDenied
@@ -526,6 +537,8 @@ impl TeaclaveManagement for TeaclaveManagementService {
.read_from_db(task.function_id.as_bytes())
.map_err(|_| TeaclaveManagementError::PermissionDenied)?;
+ log::info!("InvokeTask: get function: {:?}", function);
+
let function_arguments = task.function_arguments.clone();
let mut input_map: HashMap<String, FunctionInputFile> = HashMap::new();
let mut output_map: HashMap<String, FunctionOutputFile> =
HashMap::new();
@@ -567,6 +580,9 @@ impl TeaclaveManagement for TeaclaveManagementService {
.output_data(output_map);
self.enqueue_to_db(StagedTask::get_queue_key().as_bytes(),
&staged_task)?;
task.status = TaskStatus::Running;
+
+ log::info!("InvokeTask: staged task: {:?}", task);
+
self.write_to_db(&task)
.map_err(|_| TeaclaveManagementError::StorageError)?;
Ok(InvokeTaskResponse)
diff --git a/services/proto/src/proto/teaclave_frontend_service.proto
b/services/proto/src/proto/teaclave_frontend_service.proto
index 0ecbce2..b85bc33 100644
--- a/services/proto/src/proto/teaclave_frontend_service.proto
+++ b/services/proto/src/proto/teaclave_frontend_service.proto
@@ -133,7 +133,9 @@ message GetTaskResponse {
repeated string approved_user_list = 9;
repeated DataMap input_map = 10;
repeated DataMap output_map = 11;
- teaclave_common_proto.TaskStatus status = 12;
+ bytes return_value = 12;
+ map<string, string> output_file_hash = 13;
+ teaclave_common_proto.TaskStatus status = 14;
}
message AssignDataRequest {
diff --git a/services/proto/src/teaclave_frontend_service.rs
b/services/proto/src/teaclave_frontend_service.rs
index 2bb0e27..29c47e4 100644
--- a/services/proto/src/teaclave_frontend_service.rs
+++ b/services/proto/src/teaclave_frontend_service.rs
@@ -329,6 +329,8 @@ pub struct GetTaskResponse {
pub approved_user_list: HashSet<String>,
pub input_map: HashMap<String, String>,
pub output_map: HashMap<String, String>,
+ pub return_value: Option<Vec<u8>>,
+ pub output_file_hash: HashMap<String, String>,
pub status: TaskStatus,
}
@@ -974,6 +976,8 @@ impl std::convert::TryFrom<proto::GetTaskResponse> for
GetTaskResponse {
approved_user_list: proto.approved_user_list.into_iter().collect(),
input_map,
output_map,
+ return_value: Some(proto.return_value),
+ output_file_hash: proto.output_file_hash,
status,
};
@@ -1001,6 +1005,8 @@ impl From<GetTaskResponse> for proto::GetTaskResponse {
approved_user_list:
response.approved_user_list.into_iter().collect(),
input_map,
output_map,
+ return_value: response.return_value.unwrap_or_default(),
+ output_file_hash: response.output_file_hash,
status,
}
}
diff --git a/tests/functional/enclave/src/end_to_end.rs
b/tests/functional/enclave/src/end_to_end.rs
new file mode 100644
index 0000000..918e3de
--- /dev/null
+++ b/tests/functional/enclave/src/end_to_end.rs
@@ -0,0 +1,121 @@
+use std::collections::HashMap;
+use std::prelude::v1::*;
+use teaclave_attestation::verifier;
+use teaclave_config::RuntimeConfig;
+use teaclave_config::BUILD_CONFIG;
+use teaclave_proto::teaclave_authentication_service::*;
+use teaclave_proto::teaclave_common::*;
+use teaclave_proto::teaclave_frontend_service::*;
+use teaclave_rpc::config::SgxTrustedTlsClientConfig;
+use teaclave_rpc::endpoint::Endpoint;
+use teaclave_types::*;
+
+pub fn run_tests() -> bool {
+ use teaclave_test_utils::*;
+
+ run_tests!(test_echo_task,)
+}
+
+fn get_credential() -> UserCredential {
+ let runtime_config =
RuntimeConfig::from_toml("runtime.config.toml").expect("runtime");
+ let enclave_info =
+
EnclaveInfo::from_bytes(&runtime_config.audit.enclave_info_bytes.as_ref().unwrap());
+ let enclave_attr = enclave_info
+ .get_enclave_attr("teaclave_authentication_service")
+ .expect("authentication");
+ let config = SgxTrustedTlsClientConfig::new().attestation_report_verifier(
+ vec![enclave_attr],
+ BUILD_CONFIG.as_root_ca_cert,
+ verifier::universal_quote_verifier,
+ );
+ let channel = Endpoint::new("localhost:7776")
+ .config(config)
+ .connect()
+ .unwrap();
+ let mut api_client =
TeaclaveAuthenticationApiClient::new(channel).unwrap();
+
+ let request = UserRegisterRequest::new("frontend_user", "test_password");
+ let _response_result = api_client.user_register(request);
+
+ let request = UserLoginRequest::new("frontend_user", "test_password");
+ let response_result = api_client.user_login(request);
+ assert!(response_result.is_ok());
+ UserCredential::new("frontend_user", response_result.unwrap().token)
+}
+
+fn get_frontend_client() -> TeaclaveFrontendClient {
+ let user_credential = get_credential();
+ let runtime_config =
RuntimeConfig::from_toml("runtime.config.toml").expect("runtime");
+ let port = &runtime_config.api_endpoints.frontend.listen_address.port();
+ let channel = Endpoint::new(&format!("localhost:{}", port))
+ .connect()
+ .unwrap();
+
+ let mut metadata = HashMap::new();
+ metadata.insert("id".to_string(), user_credential.id);
+ metadata.insert("token".to_string(), user_credential.token);
+
+ TeaclaveFrontendClient::new_with_metadata(channel, metadata).unwrap()
+}
+
+fn test_echo_task() {
+ let mut client = get_frontend_client();
+
+ let request = RegisterFunctionRequest {
+ name: "echo".to_string(),
+ description: "Native Echo Function".to_string(),
+ payload: vec![],
+ is_public: true,
+ arg_list: vec!["message".to_string()],
+ input_list: vec![],
+ output_list: vec![],
+ };
+ let response = client.register_function(request).unwrap();
+
+ log::info!("Resgister function: {:?}", response);
+
+ let function_id = response.function_id;
+ let function_arguments = FunctionArguments::new(hashmap!("message" =>
"Hello From Teaclave!"));
+ let request = CreateTaskRequest {
+ function_id,
+ function_arguments,
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list: HashMap::new(),
+ };
+ let response = client.create_task(request).unwrap();
+
+ log::info!("Create task: {:?}", response);
+
+ let task_id = response.task_id;
+ let request = AssignDataRequest {
+ task_id: task_id.clone(),
+ input_map: HashMap::new(),
+ output_map: HashMap::new(),
+ };
+ let response = client.assign_data(request).unwrap();
+
+ log::info!("Assign data: {:?}", response);
+
+ let request = ApproveTaskRequest::new(&task_id);
+ let response = client.approve_task(request).unwrap();
+
+ log::info!("Approve task: {:?}", response);
+
+ let request = InvokeTaskRequest::new(&task_id);
+ let response = client.invoke_task(request).unwrap();
+
+ log::info!("Invoke task: {:?}", response);
+
+ loop {
+ let request = GetTaskRequest::new(&task_id);
+ let response = client.get_task(request).unwrap();
+ log::info!("Get task: {:?}", response);
+ std::thread::sleep(std::time::Duration::from_secs(1));
+ if response.status != TaskStatus::Running {
+ let ret_val =
String::from_utf8(response.return_value.unwrap()).unwrap();
+ log::info!("Task returns: {:?}", ret_val);
+ assert_eq!(&ret_val, "Hello From Teaclave!");
+ break;
+ }
+ }
+}
diff --git a/tests/functional/enclave/src/lib.rs
b/tests/functional/enclave/src/lib.rs
index 5476e03..24a0a40 100644
--- a/tests/functional/enclave/src/lib.rs
+++ b/tests/functional/enclave/src/lib.rs
@@ -37,6 +37,7 @@ use teaclave_types::TeeServiceResult;
mod access_control_service;
mod authentication_service;
+mod end_to_end;
mod execution_service;
mod frontend_service;
mod management_service;
@@ -66,6 +67,7 @@ fn handle_run_test(input: &RunTestInput) ->
TeeServiceResult<RunTestOutput> {
),
("scheduler_service", Box::new(scheduler_service::run_tests)),
("execution_service", Box::new(execution_service::run_tests)),
+ ("end_to_end", Box::new(end_to_end::run_tests)),
];
let test_map: HashMap<_, BoxedFnTest> =
v.into_iter().map(|(k, v)| (k.to_string(), v)).collect();
diff --git a/types/src/task.rs b/types/src/task.rs
index a16a5e2..5778de0 100644
--- a/types/src/task.rs
+++ b/types/src/task.rs
@@ -37,7 +37,7 @@ pub enum TaskStatus {
Finished,
}
-const TASK_PREFIX: &str = "task-";
+const TASK_PREFIX: &str = "task";
#[derive(Debug, Deserialize, Serialize)]
pub struct Task {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
