[task] Wrap types for Task fields (#284)
diff --git a/services/management/enclave/src/service.rs b/services/management/enclave/src/service.rs
index 7fd767a..fd5fac1 100644
--- a/services/management/enclave/src/service.rs
+++ b/services/management/enclave/src/service.rs
@@ -38,9 +38,9 @@
use teaclave_rpc::Request;
use teaclave_service_enclave_utils::{ensure, teaclave_service};
use teaclave_types::{
- ExternalID, FileCrypto, Function, FunctionInputFile, FunctionOutputFile, OwnerList, StagedTask,
- Storable, Task, TaskStatus, TeaclaveInputFile, TeaclaveOutputFile,
- TeaclaveServiceResponseError, TeaclaveServiceResponseResult, UserID,
+ ExternalID, FileCrypto, Function, OwnerList, StagedTask, Storable, Task, TaskStatus,
+ TeaclaveInputFile, TeaclaveOutputFile, TeaclaveServiceResponseError,
+ TeaclaveServiceResponseResult, UserID,
};
use thiserror::Error;
use url::Url;
@@ -272,8 +272,8 @@
user_id,
request.executor,
request.function_arguments,
- request.input_owners_map,
- request.output_owners_map,
+ request.inputs_ownership,
+ request.outputs_ownership,
function,
)
.map_err(|_| ServiceError::BadTask)?;
@@ -310,12 +310,12 @@
function_id: task.function_id,
function_owner: task.function_owner,
function_arguments: task.function_arguments,
- input_owners_map: task.input_owners_map,
- output_owners_map: task.output_owners_map,
+ inputs_ownership: task.inputs_ownership,
+ outputs_ownership: task.outputs_ownership,
participants: task.participants,
approved_users: task.approved_users,
- input_map: task.input_map,
- output_map: task.output_map,
+ assigned_inputs: task.assigned_inputs.external_ids(),
+ assigned_outputs: task.assigned_outputs.external_ids(),
result: task.result,
status: task.status,
};
@@ -329,7 +329,7 @@
// * input file: user_id == input_file.owner contains user_id
// * output file: output_file.owner contains user_id && output_file.cmac.is_none()
// 4) the data can be assgined to the task:
- // * input_owners_map or output_owners_map contains the data name
+ // * inputs_ownership or outputs_ownership contains the data name
// * input file: OwnerList match input_file.owner
// * output file: OwnerList match output_file.owner
fn assign_data(
@@ -349,19 +349,19 @@
ServiceError::PermissionDenied
);
- for (data_name, data_id) in request.input_map.iter() {
+ for (data_name, data_id) in request.inputs.iter() {
let file: TeaclaveInputFile = self
.read_from_db(&data_id)
.map_err(|_| ServiceError::PermissionDenied)?;
- task.assign_input(&user_id, data_name, &file)
+ task.assign_input(&user_id, data_name, file)
.map_err(|_| ServiceError::PermissionDenied)?;
}
- for (data_name, data_id) in request.output_map.iter() {
+ for (data_name, data_id) in request.outputs.iter() {
let file: TeaclaveOutputFile = self
.read_from_db(&data_id)
.map_err(|_| ServiceError::PermissionDenied)?;
- task.assign_output(&user_id, data_name, &file)
+ task.assign_output(&user_id, data_name, file)
.map_err(|_| ServiceError::PermissionDenied)?;
}
@@ -427,26 +427,7 @@
log::info!("InvokeTask: get function: {:?}", function);
- let mut input_map: HashMap<String, FunctionInputFile> = HashMap::new();
- for (data_name, data_id) in task.input_map.iter() {
- let input_file: TeaclaveInputFile = self
- .read_from_db(&data_id)
- .map_err(|_| ServiceError::PermissionDenied)?;
- let input_data = FunctionInputFile::from_teaclave_input_file(&input_file);
- input_map.insert(data_name.to_string(), input_data);
- }
-
- let mut output_map: HashMap<String, FunctionOutputFile> = HashMap::new();
- for (data_name, data_id) in task.output_map.iter() {
- let output_file: TeaclaveOutputFile = self
- .read_from_db(&data_id)
- .map_err(|_| ServiceError::PermissionDenied)?;
- ensure!(output_file.cmac.is_none(), ServiceError::PermissionDenied);
- let output_data = FunctionOutputFile::from_teaclave_output_file(&output_file);
- output_map.insert(data_name.to_string(), output_data);
- }
-
- let staged_task = task.stage_for_running(&user_id, function, input_map, output_map)?;
+ let staged_task = task.stage_for_running(&user_id, function)?;
log::info!("InvokeTask: staged task: {:?}", staged_task);
@@ -602,7 +583,7 @@
use std::collections::HashMap;
use teaclave_types::{
hashmap, Executor, FileAuthTag, FileCrypto, FunctionArguments, FunctionInput,
- FunctionOutput,
+ FunctionInputFile, FunctionOutput, FunctionOutputFile,
};
use url::Url;
diff --git a/services/proto/src/proto/teaclave_frontend_service.proto b/services/proto/src/proto/teaclave_frontend_service.proto
index 3957b1e..6a3dcb3 100644
--- a/services/proto/src/proto/teaclave_frontend_service.proto
+++ b/services/proto/src/proto/teaclave_frontend_service.proto
@@ -112,8 +112,8 @@
string function_id = 1;
map<string, string> function_arguments = 2;
string executor = 3;
- repeated OwnerList input_owners_map = 10;
- repeated OwnerList output_owners_map = 11;
+ repeated OwnerList inputs_ownership = 10;
+ repeated OwnerList outputs_ownership= 11;
}
message CreateTaskResponse {
@@ -130,20 +130,20 @@
string function_id = 3;
string function_owner = 4;
map<string, string> function_arguments = 5;
- repeated OwnerList input_owners_map = 6;
- repeated OwnerList output_owners_map = 7;
+ repeated OwnerList inputs_ownership = 6;
+ repeated OwnerList outputs_ownership = 7;
repeated string participants = 8;
repeated string approved_users = 9;
- repeated DataMap input_map = 10;
- repeated DataMap output_map = 11;
+ repeated DataMap assigned_inputs = 10;
+ repeated DataMap assigned_outputs = 11;
teaclave_common_proto.TaskStatus status = 20;
teaclave_common_proto.TaskResult result = 21;
}
message AssignDataRequest {
string task_id = 1;
- repeated DataMap input_map = 2;
- repeated DataMap output_map = 3;
+ repeated DataMap inputs = 2;
+ repeated DataMap outputs = 3;
}
message AssignDataResponse { }
diff --git a/services/proto/src/teaclave_frontend_service.rs b/services/proto/src/teaclave_frontend_service.rs
index 9ca53ff..cf36589 100644
--- a/services/proto/src/teaclave_frontend_service.rs
+++ b/services/proto/src/teaclave_frontend_service.rs
@@ -27,7 +27,8 @@
use teaclave_rpc::into_request;
use teaclave_types::{
Executor, ExecutorType, ExternalID, FileAuthTag, FileCrypto, Function, FunctionArguments,
- FunctionInput, FunctionOutput, OwnerList, TaskResult, TaskStatus, UserID, UserList,
+ FunctionInput, FunctionOutput, OwnerList, TaskFileOwners, TaskResult, TaskStatus, UserID,
+ UserList,
};
use url::Url;
use uuid::Uuid;
@@ -342,8 +343,8 @@
pub function_id: ExternalID,
pub function_arguments: FunctionArguments,
pub executor: Executor,
- pub input_owners_map: HashMap<String, OwnerList>,
- pub output_owners_map: HashMap<String, OwnerList>,
+ pub inputs_ownership: TaskFileOwners,
+ pub outputs_ownership: TaskFileOwners,
}
impl CreateTaskRequest {
@@ -372,16 +373,16 @@
}
}
- pub fn input_owners_map(self, map: HashMap<String, OwnerList>) -> Self {
+ pub fn inputs_ownership(self, map: impl Into<TaskFileOwners>) -> Self {
Self {
- input_owners_map: map,
+ inputs_ownership: map.into(),
..self
}
}
- pub fn output_owners_map(self, map: HashMap<String, OwnerList>) -> Self {
+ pub fn outputs_ownership(self, map: impl Into<TaskFileOwners>) -> Self {
Self {
- output_owners_map: map,
+ outputs_ownership: map.into(),
..self
}
}
@@ -420,12 +421,12 @@
pub function_id: ExternalID,
pub function_owner: UserID,
pub function_arguments: FunctionArguments,
- pub input_owners_map: HashMap<String, OwnerList>,
- pub output_owners_map: HashMap<String, OwnerList>,
+ pub inputs_ownership: TaskFileOwners,
+ pub outputs_ownership: TaskFileOwners,
pub participants: UserList,
pub approved_users: UserList,
- pub input_map: HashMap<String, ExternalID>,
- pub output_map: HashMap<String, ExternalID>,
+ pub assigned_inputs: HashMap<String, ExternalID>,
+ pub assigned_outputs: HashMap<String, ExternalID>,
pub status: TaskStatus,
pub result: TaskResult,
}
@@ -435,20 +436,20 @@
#[derive(Debug)]
pub struct AssignDataRequest {
pub task_id: ExternalID,
- pub input_map: HashMap<String, ExternalID>,
- pub output_map: HashMap<String, ExternalID>,
+ pub inputs: HashMap<String, ExternalID>,
+ pub outputs: HashMap<String, ExternalID>,
}
impl AssignDataRequest {
pub fn new(
task_id: ExternalID,
- input_map: HashMap<String, ExternalID>,
- output_map: HashMap<String, ExternalID>,
+ inputs: HashMap<String, ExternalID>,
+ outputs: HashMap<String, ExternalID>,
) -> Self {
Self {
task_id,
- input_map,
- output_map,
+ inputs,
+ outputs,
}
}
}
@@ -936,29 +937,21 @@
}
}
-pub fn data_owner_map_from_proto(
- vector: Vec<proto::OwnerList>,
-) -> Result<HashMap<String, OwnerList>> {
- let mut ret = HashMap::with_capacity(vector.len());
- for item in vector.into_iter() {
- let owner_list = item.uids.into();
- ret.insert(item.data_name, owner_list);
- }
- Ok(ret)
+fn from_proto_ownership(proto: Vec<proto::OwnerList>) -> TaskFileOwners {
+ proto
+ .into_iter()
+ .map(|ol| (ol.data_name, ol.uids))
+ .collect()
}
-pub fn data_owner_map_to_proto<S: std::hash::BuildHasher>(
- map: HashMap<String, OwnerList, S>,
-) -> Vec<proto::OwnerList> {
- let mut ret = Vec::with_capacity(map.len());
- for (data_name, owner_list) in map.into_iter() {
- let owner_list = proto::OwnerList {
- data_name,
- uids: owner_list.into(),
- };
- ret.push(owner_list);
- }
- ret
+fn to_proto_ownership(ownership: TaskFileOwners) -> Vec<proto::OwnerList> {
+ ownership
+ .into_iter()
+ .map(|(name, ol)| proto::OwnerList {
+ data_name: name,
+ uids: ol.into(),
+ })
+ .collect()
}
impl std::convert::TryFrom<proto::CreateTaskRequest> for CreateTaskRequest {
@@ -966,8 +959,8 @@
fn try_from(proto: proto::CreateTaskRequest) -> Result<Self> {
let function_arguments = proto.function_arguments.into();
- let input_owners_map = data_owner_map_from_proto(proto.input_owners_map)?;
- let output_owners_map = data_owner_map_from_proto(proto.output_owners_map)?;
+ let inputs_ownership = from_proto_ownership(proto.inputs_ownership);
+ let outputs_ownership = from_proto_ownership(proto.outputs_ownership);
let function_id = proto.function_id.try_into()?;
let executor = proto.executor.try_into()?;
@@ -975,8 +968,8 @@
function_id,
function_arguments,
executor,
- input_owners_map,
- output_owners_map,
+ inputs_ownership,
+ outputs_ownership,
};
Ok(ret)
}
@@ -985,15 +978,15 @@
impl From<CreateTaskRequest> for proto::CreateTaskRequest {
fn from(request: CreateTaskRequest) -> Self {
let function_arguments = request.function_arguments.into();
- let input_owners_map = data_owner_map_to_proto(request.input_owners_map);
- let output_owners_map = data_owner_map_to_proto(request.output_owners_map);
+ let inputs_ownership = to_proto_ownership(request.inputs_ownership);
+ let outputs_ownership = to_proto_ownership(request.outputs_ownership);
Self {
function_id: request.function_id.to_string(),
function_arguments,
executor: request.executor.to_string(),
- input_owners_map,
- output_owners_map,
+ inputs_ownership,
+ outputs_ownership,
}
}
}
@@ -1017,25 +1010,25 @@
}
}
-fn data_map_to_proto(map: HashMap<String, ExternalID>) -> Vec<proto::DataMap> {
- let mut ret = Vec::with_capacity(map.len());
- for (data_name, data_id) in map.into_iter() {
- let data_map = proto::DataMap {
- data_name,
- data_id: data_id.to_string(),
- };
- ret.push(data_map);
- }
- ret
+fn to_proto_file_ids(map: HashMap<String, ExternalID>) -> Vec<proto::DataMap> {
+ map.into_iter()
+ .map(|(name, ext_id)| proto::DataMap {
+ data_name: name,
+ data_id: ext_id.to_string(),
+ })
+ .collect()
}
-fn data_map_from_proto(vector: Vec<proto::DataMap>) -> Result<HashMap<String, ExternalID>> {
- let mut ret = HashMap::with_capacity(vector.len());
- for item in vector.into_iter() {
- let data_id = item.data_id.try_into()?;
- ret.insert(item.data_name, data_id);
- }
- Ok(ret)
+fn from_proto_file_ids(vector: Vec<proto::DataMap>) -> Result<HashMap<String, ExternalID>> {
+ vector
+ .into_iter()
+ .map(|item| {
+ item.data_id
+ .clone()
+ .try_into()
+ .map(|ext_id| (item.data_name, ext_id))
+ })
+ .collect()
}
impl std::convert::TryFrom<proto::GetTaskRequest> for GetTaskRequest {
@@ -1062,10 +1055,10 @@
fn try_from(proto: proto::GetTaskResponse) -> Result<Self> {
let function_arguments = proto.function_arguments.into();
- let input_owners_map = data_owner_map_from_proto(proto.input_owners_map)?;
- let output_owners_map = data_owner_map_from_proto(proto.output_owners_map)?;
- let input_map = data_map_from_proto(proto.input_map)?;
- let output_map = data_map_from_proto(proto.output_map)?;
+ let inputs_ownership = from_proto_ownership(proto.inputs_ownership);
+ let outputs_ownership = from_proto_ownership(proto.outputs_ownership);
+ let assigned_inputs = from_proto_file_ids(proto.assigned_inputs)?;
+ let assigned_outputs = from_proto_file_ids(proto.assigned_outputs)?;
let status = i32_to_task_status(proto.status)?;
let function_id = proto.function_id.try_into()?;
let task_id = proto.task_id.try_into()?;
@@ -1077,12 +1070,12 @@
function_id,
function_owner: proto.function_owner.into(),
function_arguments,
- input_owners_map,
- output_owners_map,
+ inputs_ownership,
+ outputs_ownership,
participants: UserList::new(proto.participants),
approved_users: UserList::new(proto.approved_users),
- input_map,
- output_map,
+ assigned_inputs,
+ assigned_outputs,
status,
result,
};
@@ -1094,10 +1087,10 @@
impl From<GetTaskResponse> for proto::GetTaskResponse {
fn from(response: GetTaskResponse) -> Self {
let function_arguments = response.function_arguments.into();
- let input_owners_map = data_owner_map_to_proto(response.input_owners_map);
- let output_owners_map = data_owner_map_to_proto(response.output_owners_map);
- let input_map = data_map_to_proto(response.input_map);
- let output_map = data_map_to_proto(response.output_map);
+ let inputs_ownership = to_proto_ownership(response.inputs_ownership);
+ let outputs_ownership = to_proto_ownership(response.outputs_ownership);
+ let assigned_inputs = to_proto_file_ids(response.assigned_inputs);
+ let assigned_outputs = to_proto_file_ids(response.assigned_outputs);
let status = i32_from_task_status(response.status);
Self {
task_id: response.task_id.to_string(),
@@ -1105,12 +1098,12 @@
function_id: response.function_id.to_string(),
function_owner: response.function_owner.to_string(),
function_arguments,
- input_owners_map,
- output_owners_map,
+ inputs_ownership,
+ outputs_ownership,
participants: response.participants.into(),
approved_users: response.approved_users.into(),
- input_map,
- output_map,
+ assigned_inputs,
+ assigned_outputs,
status,
result: Some(response.result.into()),
}
@@ -1121,13 +1114,13 @@
type Error = Error;
fn try_from(proto: proto::AssignDataRequest) -> Result<Self> {
- let input_map = data_map_from_proto(proto.input_map)?;
- let output_map = data_map_from_proto(proto.output_map)?;
+ let inputs = from_proto_file_ids(proto.inputs)?;
+ let outputs = from_proto_file_ids(proto.outputs)?;
let task_id = proto.task_id.try_into()?;
let ret = Self {
task_id,
- input_map,
- output_map,
+ inputs,
+ outputs,
};
Ok(ret)
@@ -1136,12 +1129,12 @@
impl From<AssignDataRequest> for proto::AssignDataRequest {
fn from(request: AssignDataRequest) -> Self {
- let input_map = data_map_to_proto(request.input_map);
- let output_map = data_map_to_proto(request.output_map);
+ let inputs = to_proto_file_ids(request.inputs);
+ let outputs = to_proto_file_ids(request.outputs);
Self {
task_id: request.task_id.to_string(),
- input_map,
- output_map,
+ inputs,
+ outputs,
}
}
}
diff --git a/services/scheduler/enclave/src/service.rs b/services/scheduler/enclave/src/service.rs
index fd8a438..01a88c9 100644
--- a/services/scheduler/enclave/src/service.rs
+++ b/services/scheduler/enclave/src/service.rs
@@ -30,7 +30,7 @@
use teaclave_rpc::Request;
use teaclave_service_enclave_utils::teaclave_service;
use teaclave_types::{
- ExternalID, OutputsTags, StagedTask, Storable, Task, TaskResult, TaskStatus,
+ ExternalID, OutputsTags, StagedTask, Storable, Task, TaskFiles, TaskResult, TaskStatus,
TeaclaveOutputFile, TeaclaveServiceResponseError, TeaclaveServiceResponseResult,
};
use uuid::Uuid;
@@ -127,26 +127,6 @@
.put(put_request)?;
Ok(())
}
-
- fn update_outputs_cmac(
- &self,
- task_output_map: &HashMap<String, ExternalID>,
- tags_map: &OutputsTags,
- ) -> Result<()> {
- anyhow::ensure!(
- task_output_map.len() == tags_map.len(),
- "Error: task result output tags count"
- );
- for (key, id) in task_output_map.iter() {
- let mut outfile: TeaclaveOutputFile = self.get_from_db(id)?;
- let auth_tag = tags_map
- .get(key)
- .ok_or_else(|| anyhow::anyhow!("Missing result in task result outpt tags"))?;
- outfile.assign_cmac(auth_tag)?;
- self.put_into_db(&outfile)?;
- }
- Ok(())
- }
}
impl TeaclaveScheduler for TeaclaveSchedulerService {
@@ -207,7 +187,10 @@
let mut task = self.get_task(&request.task_id)?;
if let TaskResult::Ok(outputs) = &request.task_result {
- self.update_outputs_cmac(&task.output_map, &outputs.tags_map)?;
+ for (key, auth_tag) in outputs.tags_map.iter() {
+ let outfile = task.assigned_outputs.update_cmac(key, auth_tag)?;
+ self.put_into_db(outfile)?;
+ }
};
// Updating task result means we have finished execution
diff --git a/tests/functional/enclave/src/end_to_end/builtin_gbdt_train.rs b/tests/functional/enclave/src/end_to_end/builtin_gbdt_train.rs
index 86258ee..2eae2bf 100644
--- a/tests/functional/enclave/src/end_to_end/builtin_gbdt_train.rs
+++ b/tests/functional/enclave/src/end_to_end/builtin_gbdt_train.rs
@@ -117,8 +117,8 @@
"loss" => "LAD",
"training_optimization_level" => "2"
))
- .input_owners_map(hashmap!("training_data" => vec![USERNAME]))
- .output_owners_map(hashmap!("trained_model" => vec![USERNAME]));
+ .inputs_ownership(hashmap!("training_data" => vec![USERNAME]))
+ .outputs_ownership(hashmap!("trained_model" => vec![USERNAME]));
let response = client.create_task(request).unwrap();
log::info!("Create task: {:?}", response);
diff --git a/tests/functional/enclave/src/end_to_end/mesapy_data_fusion.rs b/tests/functional/enclave/src/end_to_end/mesapy_data_fusion.rs
index 327ffd5..0630ef5 100644
--- a/tests/functional/enclave/src/end_to_end/mesapy_data_fusion.rs
+++ b/tests/functional/enclave/src/end_to_end/mesapy_data_fusion.rs
@@ -97,11 +97,11 @@
) -> ExternalID {
let request = CreateTaskRequest::new()
.function_id(function_id.to_owned())
- .input_owners_map(hashmap!(
+ .inputs_ownership(hashmap!(
"InPartyA" => vec![USERNAME1],
"InPartyB" => vec![USERNAME2]
))
- .output_owners_map(hashmap!("OutFusionData" => vec![USERNAME1, USERNAME2]))
+ .outputs_ownership(hashmap!("OutFusionData" => vec![USERNAME1, USERNAME2]))
.executor(Executor::MesaPy);
let response = client.create_task(request).unwrap();
log::info!("Create task: {:?}", response);
@@ -175,8 +175,8 @@
let task = get_task(&mut c2, &task_id);
assert!(task.status == TaskStatus::Finished);
- let fusion_id = task.output_map.get("OutFusionData").unwrap();
- let fusion_owners = task.output_owners_map.get("OutFusionData").unwrap();
+ let fusion_id = task.assigned_outputs.get("OutFusionData").unwrap();
+ let fusion_owners = task.outputs_ownership.get("OutFusionData").unwrap();
let fusion_input = register_fusion_input_from_output(&mut c2, &fusion_id);
let function_id = register_word_count_function(&mut c2);
@@ -251,7 +251,7 @@
let request = CreateTaskRequest::new()
.function_id(function_id.to_owned())
.function_arguments(hashmap!("query" => "teaclave"))
- .input_owners_map(hashmap!(
+ .inputs_ownership(hashmap!(
"InputData" => owners.to_owned()
))
.executor(Executor::MesaPy);
diff --git a/tests/functional/enclave/src/frontend_service.rs b/tests/functional/enclave/src/frontend_service.rs
index 1508c6d..9ec42bf 100644
--- a/tests/functional/enclave/src/frontend_service.rs
+++ b/tests/functional/enclave/src/frontend_service.rs
@@ -163,7 +163,7 @@
.function_id(function_id.clone())
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user", "mock_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user", "mock_user"]));
let response = authorized_client().create_task(request);
assert!(response.is_ok());
@@ -171,7 +171,7 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user", "mock_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user", "mock_user"]));
let response = unauthorized_client().create_task(request);
assert!(response.is_err());
}
@@ -186,7 +186,7 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user", "mock_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user", "mock_user"]));
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -212,7 +212,7 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user"]));
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -247,7 +247,7 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user"]));
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -281,7 +281,7 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "arg1_value"))
.executor(Executor::MesaPy)
- .output_owners_map(hashmap!("output" => vec!["frontend_user"]));
+ .outputs_ownership(hashmap!("output" => vec!["frontend_user"]));
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
diff --git a/tests/functional/enclave/src/management_service.rs b/tests/functional/enclave/src/management_service.rs
index acb0482..cc95f7f 100644
--- a/tests/functional/enclave/src/management_service.rs
+++ b/tests/functional/enclave/src/management_service.rs
@@ -175,7 +175,7 @@
assert!(response.is_ok());
}
-fn valid_create_task_request() -> CreateTaskRequest {
+fn create_valid_task_request() -> CreateTaskRequest {
let function_id =
ExternalID::try_from("function-00000000-0000-0000-0000-000000000001").unwrap();
let input_owners = hashmap!(
@@ -191,8 +191,8 @@
.function_id(function_id)
.function_arguments(hashmap!("arg1" => "data1", "arg2" => "data2"))
.executor(Executor::MesaPy)
- .input_owners_map(input_owners)
- .output_owners_map(output_owners)
+ .inputs_ownership(input_owners)
+ .outputs_ownership(output_owners)
}
#[test_case]
@@ -203,22 +203,26 @@
let response = client.create_task(request);
assert!(response.is_err());
- let request = valid_create_task_request();
+ let request = create_valid_task_request();
let response = client.create_task(request);
assert!(response.is_ok());
- let mut request = valid_create_task_request();
+ let mut request = create_valid_task_request();
request.function_arguments.inner_mut().remove("arg1");
let response = client.create_task(request);
assert!(response.is_err());
- let mut request = valid_create_task_request();
- request.input_owners_map.remove("input");
+ let mut request = create_valid_task_request();
+ request = request.inputs_ownership(hashmap!(
+ "input2" => vec!["mock_user2", "mock_user3"]
+ ));
let response = client.create_task(request);
assert!(response.is_err());
- let mut request = valid_create_task_request();
- request.output_owners_map.remove("output");
+ let mut request = create_valid_task_request();
+ request = request.outputs_ownership(hashmap!(
+ "output2" => vec!["mock_user2", "mock_user3"]
+ ));
let response = client.create_task(request);
assert!(response.is_err());
}
@@ -227,7 +231,7 @@
fn test_get_task() {
let mut client = authorized_client("mock_user");
- let request = valid_create_task_request();
+ let request = create_valid_task_request();
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -247,7 +251,7 @@
let mut client1 = authorized_client("mock_user1");
let mut client2 = authorized_client("mock_user2");
let mut client3 = authorized_client("mock_user3");
- let request = valid_create_task_request();
+ let request = create_valid_task_request();
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -312,7 +316,7 @@
let response = client1.assign_data(request);
assert!(response.is_err());
- // input_owners_map doesn't contain the name
+ // inputs_ownership doesn't contain the name
let request = AssignDataRequest::new(
task_id.clone(),
hashmap!("none" => input_file_id_user2.clone()),
@@ -321,7 +325,7 @@
let response = client2.assign_data(request);
assert!(response.is_err());
- // output_owners_map doesn't contain the name
+ // outputs_ownership doesn't contain the name
let request = AssignDataRequest::new(
task_id.clone(),
hashmap!(),
@@ -422,7 +426,7 @@
let mut client1 = authorized_client("mock_user1");
let mut client2 = authorized_client("mock_user2");
let mut client3 = authorized_client("mock_user3");
- let request = valid_create_task_request();
+ let request = create_valid_task_request();
let response = client.create_task(request).unwrap();
let task_id = response.task_id;
@@ -506,7 +510,7 @@
let mut client1 = authorized_client("mock_user1");
let mut client2 = authorized_client("mock_user2");
let mut client3 = authorized_client("mock_user3");
- let request = valid_create_task_request();
+ let request = create_valid_task_request();
let response = client.create_task(request);
assert!(response.is_ok());
let task_id = response.unwrap().task_id;
diff --git a/types/src/file.rs b/types/src/file.rs
index c2185a1..370b399 100644
--- a/types/src/file.rs
+++ b/types/src/file.rs
@@ -30,7 +30,7 @@
Uuid::new_v4()
}
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TeaclaveInputFile {
pub url: Url,
pub cmac: FileAuthTag,
@@ -39,7 +39,7 @@
pub uuid: Uuid,
}
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TeaclaveOutputFile {
pub url: Url,
pub cmac: Option<FileAuthTag>,
diff --git a/types/src/staged_task.rs b/types/src/staged_task.rs
index 71369c8..6cb930c 100644
--- a/types/src/staged_task.rs
+++ b/types/src/staged_task.rs
@@ -54,9 +54,20 @@
}
}
+impl<V> std::iter::FromIterator<(String, V)> for FunctionInputFiles
+where
+ V: Into<FunctionInputFile>,
+{
+ fn from_iter<T: IntoIterator<Item = (String, V)>>(iter: T) -> Self {
+ FunctionInputFiles {
+ inner: iter.into_iter().map(|(k, v)| (k, v.into())).collect(),
+ }
+ }
+}
+
impl std::convert::From<HashMap<String, FunctionInputFile>> for FunctionInputFiles {
fn from(entries: HashMap<String, FunctionInputFile>) -> FunctionInputFiles {
- FunctionInputFiles { inner: entries }
+ entries.into_iter().collect()
}
}
@@ -74,6 +85,23 @@
}
}
+impl<V> std::iter::FromIterator<(String, V)> for FunctionOutputFiles
+where
+ V: Into<FunctionOutputFile>,
+{
+ fn from_iter<T: IntoIterator<Item = (String, V)>>(iter: T) -> Self {
+ FunctionOutputFiles {
+ inner: iter.into_iter().map(|(k, v)| (k, v.into())).collect(),
+ }
+ }
+}
+
+impl std::convert::From<HashMap<String, FunctionOutputFile>> for FunctionOutputFiles {
+ fn from(entries: HashMap<String, FunctionOutputFile>) -> FunctionOutputFiles {
+ entries.into_iter().collect()
+ }
+}
+
impl FunctionOutputFiles {
pub fn new(entries: HashMap<String, FunctionOutputFile>) -> Self {
entries.into()
@@ -96,12 +124,6 @@
}
}
-impl std::convert::From<HashMap<String, FunctionOutputFile>> for FunctionOutputFiles {
- fn from(entries: HashMap<String, FunctionOutputFile>) -> FunctionOutputFiles {
- FunctionOutputFiles { inner: entries }
- }
-}
-
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct FunctionInputFile {
pub url: Url,
@@ -117,11 +139,13 @@
crypto_info: crypto.into(),
}
}
+}
- pub fn from_teaclave_input_file(file: &TeaclaveInputFile) -> Self {
+impl From<TeaclaveInputFile> for FunctionInputFile {
+ fn from(file: TeaclaveInputFile) -> Self {
Self {
- url: file.url.to_owned(),
- cmac: file.cmac.to_owned(),
+ url: file.url,
+ cmac: file.cmac,
crypto_info: file.crypto_info,
}
}
@@ -140,10 +164,12 @@
crypto_info: crypto.into(),
}
}
+}
- pub fn from_teaclave_output_file(file: &TeaclaveOutputFile) -> Self {
+impl From<TeaclaveOutputFile> for FunctionOutputFile {
+ fn from(file: TeaclaveOutputFile) -> Self {
Self {
- url: file.url.to_owned(),
+ url: file.url,
crypto_info: file.crypto_info,
}
}
diff --git a/types/src/task.rs b/types/src/task.rs
index 6061d38..eb24b5c 100644
--- a/types/src/task.rs
+++ b/types/src/task.rs
@@ -350,6 +350,153 @@
}
}
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct TaskFileOwners {
+ inner: HashMap<String, OwnerList>,
+}
+
+impl TaskFileOwners {
+ pub fn all_owners(&self) -> OwnerList {
+ OwnerList::unions(self.inner.values().cloned())
+ }
+
+ pub fn keys(&self) -> std::collections::hash_map::Keys<String, OwnerList> {
+ self.inner.keys()
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.inner.is_empty()
+ }
+
+ pub fn get(&self, key: &str) -> Option<&OwnerList> {
+ self.inner.get(key)
+ }
+
+ pub fn check(&self, fkey: &str, fowners: &OwnerList) -> Result<()> {
+ match self.inner.get(fkey) {
+ Some(owner_list) => {
+ ensure!(
+ owner_list == fowners,
+ "Assign: file ownership mismatch. {:?}",
+ fkey
+ );
+ }
+ None => bail!("Assign: file name not exist in ownership spec. {:?}", fkey),
+ };
+ Ok(())
+ }
+}
+
+impl<V> std::iter::FromIterator<(String, V)> for TaskFileOwners
+where
+ V: Into<OwnerList>,
+{
+ fn from_iter<T: IntoIterator<Item = (String, V)>>(iter: T) -> Self {
+ TaskFileOwners {
+ inner: HashMap::from_iter(iter.into_iter().map(|(k, v)| (k, v.into()))),
+ }
+ }
+}
+
+impl IntoIterator for TaskFileOwners {
+ type Item = (String, OwnerList);
+ type IntoIter = std::collections::hash_map::IntoIter<String, OwnerList>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.into_iter()
+ }
+}
+
+impl std::convert::From<HashMap<String, OwnerList>> for TaskFileOwners {
+ fn from(input: HashMap<String, OwnerList>) -> Self {
+ input.into_iter().collect()
+ }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TaskFiles<T: Clone> {
+ inner: HashMap<String, T>,
+}
+
+impl<T> Default for TaskFiles<T>
+where
+ T: Clone,
+{
+ fn default() -> TaskFiles<T> {
+ TaskFiles::<T> {
+ inner: HashMap::new(),
+ }
+ }
+}
+
+impl<T> TaskFiles<T>
+where
+ T: Clone + Storable,
+{
+ pub fn assign(&mut self, fname: &str, file: T) -> Result<()> {
+ ensure!(
+ self.inner.get(fname).is_none(),
+ "Assign: file already assigned. {:?}",
+ fname
+ );
+ self.inner.insert(fname.to_owned(), file);
+ Ok(())
+ }
+
+ pub fn keys(&self) -> std::collections::hash_map::Keys<String, T> {
+ self.inner.keys()
+ }
+
+ pub fn external_ids(&self) -> HashMap<String, ExternalID> {
+ self.inner
+ .iter()
+ .map(|(fname, file)| (fname.to_string(), file.external_id()))
+ .collect()
+ }
+}
+
+impl TaskFiles<TeaclaveOutputFile> {
+ pub fn update_cmac(
+ &mut self,
+ fname: &str,
+ auth_tag: &FileAuthTag,
+ ) -> Result<&TeaclaveOutputFile> {
+ let file = match self.inner.get_mut(fname) {
+ Some(file) => {
+ file.assign_cmac(auth_tag)?;
+ file
+ }
+ _ => bail!("Upadate_cmac: file not found. {:?}", fname),
+ };
+
+ Ok(file)
+ }
+}
+
+impl<T> IntoIterator for TaskFiles<T>
+where
+ T: Clone,
+{
+ type Item = (String, T);
+ type IntoIter = std::collections::hash_map::IntoIter<String, T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.into_iter()
+ }
+}
+
+impl std::convert::From<TaskFiles<TeaclaveInputFile>> for FunctionInputFiles {
+ fn from(files: TaskFiles<TeaclaveInputFile>) -> Self {
+ files.into_iter().collect()
+ }
+}
+
+impl std::convert::From<TaskFiles<TeaclaveOutputFile>> for FunctionOutputFiles {
+ fn from(files: TaskFiles<TeaclaveOutputFile>) -> Self {
+ files.into_iter().collect()
+ }
+}
+
const TASK_PREFIX: &str = "task";
#[derive(Debug, Default, Deserialize, Serialize)]
@@ -359,13 +506,13 @@
pub function_id: ExternalID,
pub function_arguments: FunctionArguments,
pub executor: Executor,
- pub input_owners_map: HashMap<String, OwnerList>,
- pub output_owners_map: HashMap<String, OwnerList>,
+ pub inputs_ownership: TaskFileOwners,
+ pub outputs_ownership: TaskFileOwners,
pub function_owner: UserID,
pub participants: UserList,
pub approved_users: UserList,
- pub input_map: HashMap<String, ExternalID>,
- pub output_map: HashMap<String, ExternalID>,
+ pub assigned_inputs: TaskFiles<TeaclaveInputFile>,
+ pub assigned_outputs: TaskFiles<TeaclaveOutputFile>,
pub result: TaskResult,
pub status: TaskStatus,
}
@@ -385,13 +532,16 @@
requester: UserID,
req_executor: Executor,
req_func_args: FunctionArguments,
- req_input_owners: HashMap<String, OwnerList>,
- req_output_owners: HashMap<String, OwnerList>,
+ req_input_owners: impl Into<TaskFileOwners>,
+ req_output_owners: impl Into<TaskFileOwners>,
function: Function,
) -> Result<Self> {
+ let req_input_owners = req_input_owners.into();
+ let req_output_owners = req_output_owners.into();
+
// gather all participants
- let input_owners = UserList::unions(req_input_owners.values().cloned());
- let output_owners = UserList::unions(req_output_owners.values().cloned());
+ let input_owners = req_input_owners.all_owners();
+ let output_owners = req_output_owners.all_owners();
let mut participants = UserList::unions(vec![input_owners, output_owners]);
participants.insert(requester.clone());
if !function.public {
@@ -427,8 +577,8 @@
function_id: function.external_id(),
function_owner: function.owner.clone(),
function_arguments: req_func_args,
- input_owners_map: req_input_owners,
- output_owners_map: req_output_owners,
+ inputs_ownership: req_input_owners,
+ outputs_ownership: req_output_owners,
participants,
status,
..Default::default()
@@ -483,8 +633,6 @@
&mut self,
requester: &UserID,
function: Function,
- input_map: HashMap<String, FunctionInputFile>,
- output_map: HashMap<String, FunctionOutputFile>,
) -> Result<StagedTask> {
ensure!(
&self.creator == requester,
@@ -505,8 +653,8 @@
function_name: function.name,
function_payload: function.payload,
function_arguments,
- input_data: input_map.into(),
- output_data: output_map.into(),
+ input_data: self.assigned_inputs.clone().into(),
+ output_data: self.assigned_outputs.clone().into(),
};
self.update_status(TaskStatus::Staged);
@@ -517,7 +665,7 @@
&mut self,
requester: &UserID,
fname: &str,
- file: &TeaclaveInputFile,
+ file: TeaclaveInputFile,
) -> Result<()> {
ensure!(
self.status == TaskStatus::Created,
@@ -531,27 +679,9 @@
file.external_id()
);
- match self.input_owners_map.get(fname) {
- Some(owner_list) => {
- ensure!(
- owner_list == &file.owner,
- "Assign: file ownership mismatch. {:?}",
- file.external_id()
- );
- }
- None => bail!(
- "Assign: file name not exist in input_owners_map. {:?}",
- fname
- ),
- };
+ self.inputs_ownership.check(fname, &file.owner)?;
- ensure!(
- self.input_map.get(fname).is_none(),
- "Assign: file already assigned. {:?}",
- fname
- );
-
- self.input_map.insert(fname.to_owned(), file.external_id());
+ self.assigned_inputs.assign(fname, file)?;
if self.all_data_assigned() {
self.update_status(TaskStatus::DataAssigned);
@@ -563,7 +693,7 @@
&mut self,
requester: &UserID,
fname: &str,
- file: &TeaclaveOutputFile,
+ file: TeaclaveOutputFile,
) -> Result<()> {
ensure!(
self.status == TaskStatus::Created,
@@ -577,27 +707,9 @@
file.external_id()
);
- match self.output_owners_map.get(fname) {
- Some(owner_list) => {
- ensure!(
- owner_list == &file.owner,
- "Assign: file ownership mismatch. {:?}",
- file.external_id()
- );
- }
- None => bail!(
- "Assign: file name not exist in output_owners_map. {:?}",
- fname
- ),
- };
+ self.outputs_ownership.check(fname, &file.owner)?;
- ensure!(
- self.output_map.get(fname).is_none(),
- "Assign: file already assigned. {:?}",
- fname
- );
-
- self.output_map.insert(fname.to_owned(), file.external_id());
+ self.assigned_outputs.assign(fname, file)?;
if self.all_data_assigned() {
self.update_status(TaskStatus::DataAssigned);
@@ -610,14 +722,14 @@
}
fn all_data_assigned(&self) -> bool {
- let input_args: HashSet<&String> = self.input_owners_map.keys().collect();
- let assiged_inputs: HashSet<&String> = self.input_map.keys().collect();
+ let input_args: HashSet<&String> = self.inputs_ownership.keys().collect();
+ let assiged_inputs: HashSet<&String> = self.assigned_inputs.keys().collect();
if input_args != assiged_inputs {
return false;
}
- let output_args: HashSet<&String> = self.output_owners_map.keys().collect();
- let assiged_outputs: HashSet<&String> = self.output_map.keys().collect();
+ let output_args: HashSet<&String> = self.outputs_ownership.keys().collect();
+ let assiged_outputs: HashSet<&String> = self.assigned_outputs.keys().collect();
if output_args != assiged_outputs {
return false;
}
