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 f2abc8a [frontend] Foward requests to managemet service (#227)
f2abc8a is described below
commit f2abc8a439b67f893fa886e09f76c46b4120cf42
Author: TX <[email protected]>
AuthorDate: Tue Feb 18 17:42:17 2020 -0800
[frontend] Foward requests to managemet service (#227)
---
services/frontend/enclave/src/service.rs | 120 ++++--
services/management/enclave/src/service.rs | 27 ++
.../src/proto/teaclave_frontend_service.proto | 10 +
services/proto/src/teaclave_frontend_service.rs | 9 +
.../enclave/src/teaclave_frontend_service.rs | 444 ++++++++++++++++++++-
5 files changed, 573 insertions(+), 37 deletions(-)
diff --git a/services/frontend/enclave/src/service.rs
b/services/frontend/enclave/src/service.rs
index 3909f69..8b32b65 100644
--- a/services/frontend/enclave/src/service.rs
+++ b/services/frontend/enclave/src/service.rs
@@ -6,8 +6,13 @@ use teaclave_proto::teaclave_authentication_service::{
};
use teaclave_proto::teaclave_common::UserCredential;
use teaclave_proto::teaclave_frontend_service::{
- RegisterInputFileRequest, RegisterInputFileResponse,
RegisterOutputFileRequest,
- RegisterOutputFileResponse, TeaclaveFrontend,
+ ApproveTaskRequest, ApproveTaskResponse, AssignDataRequest,
AssignDataResponse,
+ CreateTaskRequest, CreateTaskResponse, GetFunctionRequest,
GetFunctionResponse,
+ GetFusionDataRequest, GetFusionDataResponse, GetOutputFileRequest,
GetOutputFileResponse,
+ GetTaskRequest, GetTaskResponse, InvokeTaskRequest, InvokeTaskResponse,
+ RegisterFunctionRequest, RegisterFunctionResponse,
RegisterInputFileRequest,
+ RegisterInputFileResponse, RegisterOutputFileRequest,
RegisterOutputFileResponse,
+ TeaclaveFrontend,
};
use teaclave_proto::teaclave_management_service::TeaclaveManagementClient;
use teaclave_rpc::endpoint::Endpoint;
@@ -20,6 +25,8 @@ use thiserror::Error;
enum TeaclaveFrontendError {
#[error("authentication error")]
AuthenticationError,
+ #[error("lock error")]
+ LockError,
}
impl From<TeaclaveFrontendError> for TeaclaveServiceResponseError {
@@ -35,6 +42,28 @@ pub(crate) struct TeaclaveFrontendService {
management_client: Arc<Mutex<TeaclaveManagementClient>>,
}
+macro_rules! forward_to_management {
+ ($service: ident, $request: ident, $func: ident) => {{
+ match $service.authenticate(&$request) {
+ Ok(true) => (),
+ _ => return Err(TeaclaveFrontendError::AuthenticationError.into()),
+ }
+
+ let client = $service.management_client.clone();
+ let mut client = client
+ .lock()
+ .map_err(|_| TeaclaveFrontendError::LockError)?;
+ client.metadata_mut().clear();
+ client.metadata_mut().extend($request.metadata);
+
+ let response = client.$func($request.message);
+
+ client.metadata_mut().clear();
+ let response = response?;
+ Ok(response)
+ }};
+}
+
impl TeaclaveFrontendService {
pub(crate) fn new(
authentication_service_endpoint: Endpoint,
@@ -62,34 +91,77 @@ impl TeaclaveFrontend for TeaclaveFrontendService {
&self,
request: Request<RegisterInputFileRequest>,
) -> TeaclaveServiceResponseResult<RegisterInputFileResponse> {
- match self.authenticate(&request) {
- Ok(true) => (),
- _ => return Err(TeaclaveFrontendError::AuthenticationError.into()),
- }
- let response = self
- .management_client
- .clone()
- .lock()
- .unwrap()
- .register_input_file(request.message)?;
- Ok(response)
+ forward_to_management!(self, request, register_input_file)
}
fn register_output_file(
&self,
request: Request<RegisterOutputFileRequest>,
) -> TeaclaveServiceResponseResult<RegisterOutputFileResponse> {
- match self.authenticate(&request) {
- Ok(true) => (),
- _ => return Err(TeaclaveFrontendError::AuthenticationError.into()),
- }
- let response = self
- .management_client
- .clone()
- .lock()
- .unwrap()
- .register_output_file(request.message)?;
- Ok(response)
+ forward_to_management!(self, request, register_output_file)
+ }
+
+ fn get_output_file(
+ &self,
+ request: Request<GetOutputFileRequest>,
+ ) -> TeaclaveServiceResponseResult<GetOutputFileResponse> {
+ forward_to_management!(self, request, get_output_file)
+ }
+
+ fn get_fusion_data(
+ &self,
+ request: Request<GetFusionDataRequest>,
+ ) -> TeaclaveServiceResponseResult<GetFusionDataResponse> {
+ forward_to_management!(self, request, get_fusion_data)
+ }
+
+ fn register_function(
+ &self,
+ request: Request<RegisterFunctionRequest>,
+ ) -> TeaclaveServiceResponseResult<RegisterFunctionResponse> {
+ forward_to_management!(self, request, register_function)
+ }
+
+ fn get_function(
+ &self,
+ request: Request<GetFunctionRequest>,
+ ) -> TeaclaveServiceResponseResult<GetFunctionResponse> {
+ forward_to_management!(self, request, get_function)
+ }
+
+ fn create_task(
+ &self,
+ request: Request<CreateTaskRequest>,
+ ) -> TeaclaveServiceResponseResult<CreateTaskResponse> {
+ forward_to_management!(self, request, create_task)
+ }
+
+ fn get_task(
+ &self,
+ request: Request<GetTaskRequest>,
+ ) -> TeaclaveServiceResponseResult<GetTaskResponse> {
+ forward_to_management!(self, request, get_task)
+ }
+
+ fn assign_data(
+ &self,
+ request: Request<AssignDataRequest>,
+ ) -> TeaclaveServiceResponseResult<AssignDataResponse> {
+ forward_to_management!(self, request, assign_data)
+ }
+
+ fn approve_task(
+ &self,
+ request: Request<ApproveTaskRequest>,
+ ) -> TeaclaveServiceResponseResult<ApproveTaskResponse> {
+ forward_to_management!(self, request, approve_task)
+ }
+
+ fn invoke_task(
+ &self,
+ request: Request<InvokeTaskRequest>,
+ ) -> TeaclaveServiceResponseResult<InvokeTaskResponse> {
+ forward_to_management!(self, request, invoke_task)
}
}
diff --git a/services/management/enclave/src/service.rs
b/services/management/enclave/src/service.rs
index 920923a..8debe7e 100644
--- a/services/management/enclave/src/service.rs
+++ b/services/management/enclave/src/service.rs
@@ -440,6 +440,13 @@ impl TeaclaveManagementService {
let value = fusion_data.to_vec()?;
self.write_to_storage(&key, &value)?;
+ let mut fusion_data =
+ FusionData::new(vec!["frontend_user".to_string(),
"mock_user".to_string()])?;
+ fusion_data.data_id = "fusion-data-mock-frontend-data".to_string();
+ let key = fusion_data.get_key_vec();
+ let value = fusion_data.to_vec()?;
+ self.write_to_storage(&key, &value)?;
+
let function_input = FunctionInput {
name: "input".to_string(),
description: "input_desc".to_string(),
@@ -473,6 +480,26 @@ impl TeaclaveManagementService {
let value = native_function.to_vec()?;
self.write_to_storage(&key, &value)?;
+ let function_output = FunctionOutput {
+ name: "output".to_string(),
+ description: "output_desc".to_string(),
+ };
+ let native_function = Function {
+ function_id: "native-mock-simple-func".to_string(),
+ name: "mock-native-func".to_string(),
+ description: "mock-desc".to_string(),
+ payload: b"mock-payload".to_vec(),
+ is_public: true,
+ arg_list: vec!["arg1".to_string()],
+ input_list: vec![],
+ output_list: vec![function_output],
+ owner: "teaclave".to_string(),
+ is_native: true,
+ };
+ let key = native_function.get_key_vec();
+ let value = native_function.to_vec()?;
+ self.write_to_storage(&key, &value)?;
+
let url = Url::parse("s3://bucket_id/path?token=mock_token").unwrap();
let user_id = "mock_user1".to_string();
let crypto_info = TeaclaveFileCryptoInfo::default();
diff --git a/services/proto/src/proto/teaclave_frontend_service.proto
b/services/proto/src/proto/teaclave_frontend_service.proto
index c07bf7e..c24eba2 100644
--- a/services/proto/src/proto/teaclave_frontend_service.proto
+++ b/services/proto/src/proto/teaclave_frontend_service.proto
@@ -156,4 +156,14 @@ message InvokeTaskResponse { }
service TeaclaveFrontend {
rpc RegisterInputFile (RegisterInputFileRequest) returns
(RegisterInputFileResponse);
rpc RegisterOutputFile (RegisterOutputFileRequest) returns
(RegisterOutputFileResponse);
+ rpc GetOutputFile (GetOutputFileRequest) returns (GetOutputFileResponse);
+ rpc GetFusionData (GetFusionDataRequest) returns (GetFusionDataResponse);
+ rpc RegisterFunction (RegisterFunctionRequest) returns
(RegisterFunctionResponse);
+ rpc GetFunction (GetFunctionRequest) returns (GetFunctionResponse);
+ rpc CreateTask (CreateTaskRequest) returns (CreateTaskResponse);
+ rpc GetTask (GetTaskRequest) returns (GetTaskResponse);
+ rpc AssignData (AssignDataRequest) returns (AssignDataResponse);
+ rpc ApproveTask (ApproveTaskRequest) returns (ApproveTaskResponse);
+ rpc InvokeTask (InvokeTaskRequest) returns (InvokeTaskResponse);
+
}
diff --git a/services/proto/src/teaclave_frontend_service.rs
b/services/proto/src/teaclave_frontend_service.rs
index 76e35cd..de28fd4 100644
--- a/services/proto/src/teaclave_frontend_service.rs
+++ b/services/proto/src/teaclave_frontend_service.rs
@@ -49,6 +49,7 @@ pub struct RegisterOutputFileResponse {
}
#[into_request(TeaclaveManagementRequest::GetOutputFile)]
+#[into_request(TeaclaveFrontendRequest::GetOutputFile)]
#[derive(Debug)]
pub struct GetOutputFileRequest {
pub data_id: String,
@@ -61,6 +62,7 @@ pub struct GetOutputFileResponse {
}
#[into_request(TeaclaveManagementRequest::GetFusionData)]
+#[into_request(TeaclaveFrontendRequest::GetFusionData)]
#[derive(Debug)]
pub struct GetFusionDataRequest {
pub data_id: String,
@@ -86,6 +88,7 @@ pub struct FunctionOutput {
}
#[into_request(TeaclaveManagementRequest::RegisterFunction)]
+#[into_request(TeaclaveFrontendRequest::RegisterFunction)]
#[derive(Debug)]
pub struct RegisterFunctionRequest {
pub name: String,
@@ -104,6 +107,7 @@ pub struct RegisterFunctionResponse {
}
#[into_request(TeaclaveManagementRequest::GetFunction)]
+#[into_request(TeaclaveFrontendRequest::GetFunction)]
#[derive(Debug)]
pub struct GetFunctionRequest {
pub function_id: String,
@@ -128,6 +132,7 @@ pub struct DataOwnerList {
}
#[into_request(TeaclaveManagementRequest::CreateTask)]
+#[into_request(TeaclaveFrontendRequest::CreateTask)]
#[derive(Debug)]
pub struct CreateTaskRequest {
pub function_id: String,
@@ -159,6 +164,7 @@ pub enum TaskStatus {
}
#[into_request(TeaclaveManagementRequest::GetTask)]
+#[into_request(TeaclaveFrontendRequest::GetTask)]
#[derive(Debug)]
pub struct GetTaskRequest {
pub task_id: String,
@@ -182,6 +188,7 @@ pub struct GetTaskResponse {
}
#[into_request(TeaclaveManagementRequest::AssignData)]
+#[into_request(TeaclaveFrontendRequest::AssignData)]
#[derive(Debug)]
pub struct AssignDataRequest {
pub task_id: String,
@@ -193,6 +200,7 @@ pub struct AssignDataRequest {
pub struct AssignDataResponse;
#[into_request(TeaclaveManagementRequest::ApproveTask)]
+#[into_request(TeaclaveFrontendRequest::ApproveTask)]
#[derive(Debug)]
pub struct ApproveTaskRequest {
pub task_id: String,
@@ -202,6 +210,7 @@ pub struct ApproveTaskRequest {
pub struct ApproveTaskResponse;
#[into_request(TeaclaveManagementRequest::InvokeTask)]
+#[into_request(TeaclaveFrontendRequest::InvokeTask)]
#[derive(Debug)]
pub struct InvokeTaskRequest {
pub task_id: String,
diff --git a/tests/functional/enclave/src/teaclave_frontend_service.rs
b/tests/functional/enclave/src/teaclave_frontend_service.rs
index a77e2cb..ca2e2a3 100644
--- a/tests/functional/enclave/src/teaclave_frontend_service.rs
+++ b/tests/functional/enclave/src/teaclave_frontend_service.rs
@@ -1,7 +1,12 @@
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::*;
use url::Url;
@@ -9,35 +14,85 @@ use url::Url;
pub fn run_tests() -> bool {
use teaclave_test_utils::*;
- run_tests!(test_register_input_file_authentication_error)
+ run_tests!(
+ test_register_input_file,
+ test_register_output_file,
+ test_get_output_file,
+ test_get_fusion_data,
+ test_register_function,
+ test_get_function,
+ test_create_task,
+ test_get_task,
+ test_assign_data,
+ test_approve_task,
+ test_invoke_task,
+ )
+}
+
+fn get_credential() -> UserCredential {
+ // register user and login
+ 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_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();
- TeaclaveFrontendClient::new(channel).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_register_input_file_authentication_error() {
+fn test_register_input_file() {
+ let mut client = get_client();
+
let request = RegisterInputFileRequest {
url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
hash: "deadbeefdeadbeef".to_string(),
- crypto_info: TeaclaveFileCryptoInfo::AesGcm128(AesGcm128CryptoInfo {
- key: [0x90u8; 16],
- iv: [0x89u8; 12],
- }),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
};
-
- let mut metadata = HashMap::new();
- metadata.insert("id".to_string(), "".to_string());
- metadata.insert("token".to_string(), "".to_string());
-
- let mut client = get_client();
let response = client.register_input_file(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().data_id.is_empty());
+ let request = RegisterInputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ hash: "deadbeefdeadbeef".to_string(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.register_input_file(request);
assert_eq!(
response,
Err(TeaclaveServiceResponseError::RequestError(
@@ -45,3 +100,366 @@ fn test_register_input_file_authentication_error() {
))
);
}
+
+fn test_register_output_file() {
+ let mut client = get_client();
+
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ let response = client.register_output_file(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().data_id.is_empty());
+
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.register_output_file(request);
+ assert!(response.is_err());
+}
+
+fn test_get_output_file() {
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+
+ let mut client = get_client();
+ let response = client.register_output_file(request);
+ let data_id = response.unwrap().data_id;
+
+ let request = GetOutputFileRequest {
+ data_id: data_id.clone(),
+ };
+ let response = client.get_output_file(request);
+ assert!(response.is_ok());
+ assert!(response.unwrap().hash.is_empty());
+
+ let request = GetOutputFileRequest { data_id };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.get_output_file(request);
+ assert!(response.is_err());
+}
+
+fn test_get_fusion_data() {
+ let mut client = get_client();
+
+ let request = GetFusionDataRequest {
+ data_id: "fusion-data-mock-frontend-data".to_string(),
+ };
+ let response = client.get_fusion_data(request);
+ assert!(response.is_ok());
+ assert!(response.unwrap().hash.is_empty());
+
+ let request = GetFusionDataRequest {
+ data_id: "fusion-data-mock-frontend-data".to_string(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.get_fusion_data(request);
+ assert!(response.is_err());
+}
+
+fn test_register_function() {
+ let mut client = get_client();
+
+ let request = RegisterFunctionRequest {
+ name: "mock_function".to_string(),
+ description: "mock function".to_string(),
+ payload: b"python script".to_vec(),
+ is_public: true,
+ arg_list: vec!["arg".to_string()],
+ input_list: vec![],
+ output_list: vec![],
+ };
+ let response = client.register_function(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().function_id.is_empty());
+
+ let request = RegisterFunctionRequest {
+ name: "mock_function".to_string(),
+ description: "mock function".to_string(),
+ payload: b"python script".to_vec(),
+ is_public: true,
+ arg_list: vec!["arg".to_string()],
+ input_list: vec![],
+ output_list: vec![],
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.register_function(request);
+ assert!(response.is_err());
+}
+
+fn test_get_function() {
+ let mut client = get_client();
+
+ let request = GetFunctionRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ };
+ let response = client.get_function(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().name.is_empty());
+
+ let request = GetFunctionRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.get_function(request);
+ assert!(response.is_err());
+}
+
+fn test_create_task() {
+ let mut client = get_client();
+
+ let data_owner_id_list = DataOwnerList {
+ user_id_list: vec!["frontend_user".to_string(),
"mock_user".to_string()]
+ .into_iter()
+ .collect(),
+ };
+ let mut output_data_owner_list = HashMap::new();
+ output_data_owner_list.insert("output".to_string(), data_owner_id_list);
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list: output_data_owner_list.clone(),
+ };
+ let response = client.create_task(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().task_id.is_empty());
+
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list,
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.create_task(request);
+ assert!(response.is_err());
+}
+
+fn test_get_task() {
+ let mut client = get_client();
+
+ let data_owner_id_list = DataOwnerList {
+ user_id_list: vec!["frontend_user".to_string(),
"mock_user".to_string()]
+ .into_iter()
+ .collect(),
+ };
+ let mut output_data_owner_list = HashMap::new();
+ output_data_owner_list.insert("output".to_string(), data_owner_id_list);
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list,
+ };
+ let response = client.create_task(request);
+ let task_id = response.unwrap().task_id;
+
+ let request = GetTaskRequest {
+ task_id: task_id.clone(),
+ };
+ let response = client.get_task(request);
+ assert!(response.is_ok());
+ assert!(!response.unwrap().function_id.is_empty());
+
+ let request = GetTaskRequest { task_id };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.get_task(request);
+ assert!(response.is_err());
+}
+
+fn test_assign_data() {
+ let mut client = get_client();
+
+ let data_owner_id_list = DataOwnerList {
+ user_id_list: vec!["frontend_user".to_string()].into_iter().collect(),
+ };
+ let mut output_data_owner_list = HashMap::new();
+ output_data_owner_list.insert("output".to_string(), data_owner_id_list);
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list,
+ };
+ let response = client.create_task(request);
+ let task_id = response.unwrap().task_id;
+
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ let response = client.register_output_file(request);
+ let output_id = response.unwrap().data_id;
+
+ let request = AssignDataRequest {
+ task_id: task_id.clone(),
+ input_map: HashMap::new(),
+ output_map: vec![("output".to_string(), output_id.clone())]
+ .into_iter()
+ .collect(),
+ };
+ let correct_token = client.metadata().get("token").unwrap().to_string();
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.assign_data(request);
+ assert!(response.is_err());
+
+ let request = AssignDataRequest {
+ task_id,
+ input_map: HashMap::new(),
+ output_map: vec![("output".to_string(), output_id)]
+ .into_iter()
+ .collect(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), correct_token);
+ let response = client.assign_data(request);
+ assert!(response.is_ok());
+}
+
+fn test_approve_task() {
+ let mut client = get_client();
+
+ let data_owner_id_list = DataOwnerList {
+ user_id_list: vec!["frontend_user".to_string()].into_iter().collect(),
+ };
+ let mut output_data_owner_list = HashMap::new();
+ output_data_owner_list.insert("output".to_string(), data_owner_id_list);
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list,
+ };
+ let response = client.create_task(request);
+ let task_id = response.unwrap().task_id;
+
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ let response = client.register_output_file(request);
+ let output_id = response.unwrap().data_id;
+
+ let request = AssignDataRequest {
+ task_id: task_id.clone(),
+ input_map: HashMap::new(),
+ output_map: vec![("output".to_string(), output_id)]
+ .into_iter()
+ .collect(),
+ };
+ let _response = client.assign_data(request);
+
+ let request = ApproveTaskRequest {
+ task_id: task_id.clone(),
+ };
+ let correct_token = client.metadata().get("token").unwrap().to_string();
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.approve_task(request);
+ assert!(response.is_err());
+
+ let request = ApproveTaskRequest { task_id };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), correct_token);
+ let response = client.approve_task(request);
+ assert!(response.is_ok());
+}
+
+fn test_invoke_task() {
+ let mut client = get_client();
+
+ let data_owner_id_list = DataOwnerList {
+ user_id_list: vec!["frontend_user".to_string()].into_iter().collect(),
+ };
+ let mut output_data_owner_list = HashMap::new();
+ output_data_owner_list.insert("output".to_string(), data_owner_id_list);
+ let request = CreateTaskRequest {
+ function_id: "native-mock-simple-func".to_string(),
+ arg_list: vec![("arg1".to_string(), "data1".to_string())]
+ .into_iter()
+ .collect(),
+ input_data_owner_list: HashMap::new(),
+ output_data_owner_list,
+ };
+ let response = client.create_task(request);
+ let task_id = response.unwrap().task_id;
+
+ let request = RegisterOutputFileRequest {
+ url:
Url::parse("s3://s3.us-west-2.amazonaws.com/mybucket/puppy.jpg.enc?key-id=deadbeefdeadbeef&key=deadbeefdeadbeef").unwrap(),
+ crypto_info: TeaclaveFileCryptoInfo::default(),
+ };
+ let response = client.register_output_file(request);
+ let output_id = response.unwrap().data_id;
+
+ let request = AssignDataRequest {
+ task_id: task_id.clone(),
+ input_map: HashMap::new(),
+ output_map: vec![("output".to_string(), output_id)]
+ .into_iter()
+ .collect(),
+ };
+ let _response = client.assign_data(request);
+
+ let request = ApproveTaskRequest {
+ task_id: task_id.clone(),
+ };
+ let _response = client.approve_task(request);
+
+ let request = InvokeTaskRequest {
+ task_id: task_id.clone(),
+ };
+ let correct_token = client.metadata().get("token").unwrap().to_string();
+ client
+ .metadata_mut()
+ .insert("token".to_string(), "wrong token".to_string());
+ let response = client.invoke_task(request);
+ assert!(response.is_err());
+
+ let request = InvokeTaskRequest {
+ task_id: task_id.clone(),
+ };
+ client
+ .metadata_mut()
+ .insert("token".to_string(), correct_token);
+ let response = client.invoke_task(request);
+ assert!(response.is_ok());
+
+ let request = GetTaskRequest { task_id };
+ let response = client.get_task(request);
+ assert_eq!(response.unwrap().status, TaskStatus::Running);
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
