|
|
|
@ -1,34 +1,28 @@ |
|
|
|
use crate::{ |
|
|
|
use crate::{ |
|
|
|
cache::JobCache, |
|
|
|
cache::JobCache, |
|
|
|
executor::{DynFut, Waiter}, |
|
|
|
executor::{ExecResult, Waiter}, |
|
|
|
messaging::Reportable, |
|
|
|
models::{Agent, AssignedJob, AssignedJobById, JobMeta, JobType}, |
|
|
|
models::{Agent, AssignedJob, JobMeta, JobType, RawJobMeta}, |
|
|
|
|
|
|
|
utils::{CombinedResult, OneOrVec, Platform}, |
|
|
|
utils::{CombinedResult, OneOrVec, Platform}, |
|
|
|
|
|
|
|
utils::{ProcOutput, TempFile}, |
|
|
|
UError, UResult, |
|
|
|
UError, UResult, |
|
|
|
}; |
|
|
|
}; |
|
|
|
use std::collections::HashMap; |
|
|
|
use std::collections::HashMap; |
|
|
|
|
|
|
|
use std::process::exit; |
|
|
|
|
|
|
|
use tokio::process::Command; |
|
|
|
|
|
|
|
|
|
|
|
pub struct JobBuilder { |
|
|
|
pub struct JobRunner { |
|
|
|
waiter: Waiter, |
|
|
|
waiter: Waiter, |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
impl JobBuilder { |
|
|
|
impl JobRunner { |
|
|
|
pub fn from_request(job_requests: impl OneOrVec<AssignedJob>) -> CombinedResult<Self> { |
|
|
|
pub fn from_jobs(jobs: impl OneOrVec<AssignedJobById>) -> CombinedResult<Self> { |
|
|
|
let job_requests = job_requests.into_vec(); |
|
|
|
let jobs = jobs.into_vec(); |
|
|
|
let mut prepared: Vec<DynFut> = vec![]; |
|
|
|
let mut waiter = Waiter::new(); |
|
|
|
let mut result = CombinedResult::<JobBuilder, _>::new(); |
|
|
|
let mut result = CombinedResult::<Self, _>::new(); |
|
|
|
for req in job_requests { |
|
|
|
for job in jobs { |
|
|
|
let job_meta = JobCache::get(req.job_id); |
|
|
|
|
|
|
|
if job_meta.is_none() { |
|
|
|
|
|
|
|
result.err(UError::NoJob(req.job_id)); |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
let job_meta = job_meta.unwrap(); |
|
|
|
|
|
|
|
//waiting for try-blocks stabilization
|
|
|
|
//waiting for try-blocks stabilization
|
|
|
|
let built_req = (|| -> UResult<()> { |
|
|
|
let built_job = (|| -> UResult<()> { |
|
|
|
Ok(match job_meta.exec_type { |
|
|
|
let meta = JobCache::get(job.job_id).ok_or(UError::NoJob(job.job_id))?; |
|
|
|
JobType::Shell => { |
|
|
|
|
|
|
|
let meta = JobCache::get(req.job_id).ok_or(UError::NoJob(req.job_id))?; |
|
|
|
|
|
|
|
let curr_platform = Platform::current(); |
|
|
|
let curr_platform = Platform::current(); |
|
|
|
if !curr_platform.matches(&meta.platform) { |
|
|
|
if !curr_platform.matches(&meta.platform) { |
|
|
|
return Err(UError::InsuitablePlatform( |
|
|
|
return Err(UError::InsuitablePlatform( |
|
|
|
@ -37,61 +31,106 @@ impl JobBuilder { |
|
|
|
) |
|
|
|
) |
|
|
|
.into()); |
|
|
|
.into()); |
|
|
|
} |
|
|
|
} |
|
|
|
let job = AssignedJob::new(req.job_id, Some(&req)); |
|
|
|
let job = AssignedJob::from((&*meta, job)); |
|
|
|
prepared.push(Box::pin(job.run())) |
|
|
|
waiter.push(run_assigned_job(job)); |
|
|
|
} |
|
|
|
Ok(()) |
|
|
|
JobType::Manage => prepared.push(Box::pin(Agent::run())), |
|
|
|
|
|
|
|
_ => todo!(), |
|
|
|
|
|
|
|
}) |
|
|
|
|
|
|
|
})(); |
|
|
|
})(); |
|
|
|
if let Err(e) = built_req { |
|
|
|
if let Err(e) = built_job { |
|
|
|
result.err(e) |
|
|
|
result.err(e) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
result.ok(Self { |
|
|
|
result.ok(Self { waiter }); |
|
|
|
waiter: Waiter::new(prepared), |
|
|
|
|
|
|
|
}); |
|
|
|
|
|
|
|
result |
|
|
|
result |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
pub fn from_meta(job_metas: impl OneOrVec<JobMeta>) -> CombinedResult<Self> { |
|
|
|
pub fn from_meta(metas: impl OneOrVec<JobMeta>) -> CombinedResult<Self> { |
|
|
|
let job_requests = job_metas |
|
|
|
let jobs = metas |
|
|
|
.into_vec() |
|
|
|
.into_vec() |
|
|
|
.into_iter() |
|
|
|
.into_iter() |
|
|
|
.map(|jm| { |
|
|
|
.map(|jm| { |
|
|
|
let j_uid = jm.id; |
|
|
|
let job_uid = jm.id; |
|
|
|
JobCache::insert(jm); |
|
|
|
JobCache::insert(jm); |
|
|
|
AssignedJob::new(j_uid, None) |
|
|
|
AssignedJobById { |
|
|
|
|
|
|
|
job_id: job_uid, |
|
|
|
|
|
|
|
..Default::default() |
|
|
|
|
|
|
|
} |
|
|
|
}) |
|
|
|
}) |
|
|
|
.collect::<Vec<AssignedJob>>(); |
|
|
|
.collect::<Vec<AssignedJobById>>(); |
|
|
|
JobBuilder::from_request(job_requests) |
|
|
|
JobRunner::from_jobs(jobs) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Spawn jobs and pop results later
|
|
|
|
/// Spawn jobs
|
|
|
|
pub async fn spawn(mut self) -> Self { |
|
|
|
pub async fn spawn(mut self) -> Self { |
|
|
|
self.waiter = self.waiter.spawn().await; |
|
|
|
self.waiter = self.waiter.spawn().await; |
|
|
|
self |
|
|
|
self |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Spawn jobs and wait for result
|
|
|
|
/// Spawn jobs and wait for result
|
|
|
|
pub async fn wait(self) -> Vec<Reportable> { |
|
|
|
pub async fn wait(self) -> Vec<ExecResult> { |
|
|
|
self.waiter.spawn().await.wait().await |
|
|
|
self.waiter.spawn().await.wait().await |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Spawn one job and wait for result
|
|
|
|
/// Spawn one job and wait for result
|
|
|
|
pub async fn wait_one(self) -> Reportable { |
|
|
|
pub async fn wait_one(self) -> ExecResult { |
|
|
|
self.waiter.spawn().await.wait().await.pop().unwrap() |
|
|
|
self.waiter.spawn().await.wait().await.pop().unwrap() |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pub async fn run_assigned_job(mut job: AssignedJob) -> ExecResult { |
|
|
|
|
|
|
|
match job.exec_type { |
|
|
|
|
|
|
|
JobType::Shell => { |
|
|
|
|
|
|
|
let (argv, _payload) = { |
|
|
|
|
|
|
|
let meta = JobCache::get(job.job_id).unwrap(); |
|
|
|
|
|
|
|
if let Some(ref payload) = meta.payload { |
|
|
|
|
|
|
|
let extracted_payload = match TempFile::write_exec(payload) { |
|
|
|
|
|
|
|
Ok(p) => p, |
|
|
|
|
|
|
|
Err(e) => return Err(UError::Runtime(e.to_string())), |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
( |
|
|
|
|
|
|
|
meta.argv.replace("{}", &extracted_payload.get_path()), |
|
|
|
|
|
|
|
Some(extracted_payload), |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
} else { |
|
|
|
|
|
|
|
(meta.argv.clone(), None) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
let mut split_cmd = shlex::split(&argv).unwrap().into_iter(); |
|
|
|
|
|
|
|
let cmd = split_cmd.nth(0).unwrap(); |
|
|
|
|
|
|
|
let args = split_cmd.collect::<Vec<String>>(); |
|
|
|
|
|
|
|
let cmd_result = Command::new(cmd).args(args).output().await; |
|
|
|
|
|
|
|
let (data, retcode) = match cmd_result { |
|
|
|
|
|
|
|
Ok(output) => ( |
|
|
|
|
|
|
|
ProcOutput::from_output(&output).into_combined(), |
|
|
|
|
|
|
|
output.status.code(), |
|
|
|
|
|
|
|
), |
|
|
|
|
|
|
|
Err(e) => ( |
|
|
|
|
|
|
|
ProcOutput::new() |
|
|
|
|
|
|
|
.stderr(e.to_string().into_bytes()) |
|
|
|
|
|
|
|
.into_combined(), |
|
|
|
|
|
|
|
None, |
|
|
|
|
|
|
|
), |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
job.result = Some(data); |
|
|
|
|
|
|
|
job.retcode = retcode; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
JobType::Init => { |
|
|
|
|
|
|
|
job.set_result(&Agent::run().await); |
|
|
|
|
|
|
|
job.retcode = Some(0); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
JobType::Update => todo!(), |
|
|
|
|
|
|
|
JobType::Terminate => exit(0), |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
Ok(job) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Store jobs and get results by name
|
|
|
|
/// Store jobs and get results by name
|
|
|
|
pub struct NamedJobBuilder { |
|
|
|
pub struct NamedJobRunner { |
|
|
|
builder: Option<JobBuilder>, |
|
|
|
builder: Option<JobRunner>, |
|
|
|
job_names: Vec<&'static str>, |
|
|
|
job_names: Vec<&'static str>, |
|
|
|
results: HashMap<&'static str, Reportable>, |
|
|
|
results: HashMap<&'static str, ExecResult>, |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
impl NamedJobBuilder { |
|
|
|
impl NamedJobRunner { |
|
|
|
pub fn from_shell( |
|
|
|
pub fn from_shell( |
|
|
|
named_jobs: impl OneOrVec<(&'static str, &'static str)>, |
|
|
|
named_jobs: impl OneOrVec<(&'static str, &'static str)>, |
|
|
|
) -> CombinedResult<Self> { |
|
|
|
) -> CombinedResult<Self> { |
|
|
|
@ -100,7 +139,7 @@ impl NamedJobBuilder { |
|
|
|
.into_vec() |
|
|
|
.into_vec() |
|
|
|
.into_iter() |
|
|
|
.into_iter() |
|
|
|
.filter_map( |
|
|
|
.filter_map( |
|
|
|
|(alias, cmd)| match RawJobMeta::builder().with_shell(cmd).build() { |
|
|
|
|(alias, cmd)| match JobMeta::builder().with_shell(cmd).build() { |
|
|
|
Ok(meta) => Some((alias, meta)), |
|
|
|
Ok(meta) => Some((alias, meta)), |
|
|
|
Err(e) => { |
|
|
|
Err(e) => { |
|
|
|
result.err(e); |
|
|
|
result.err(e); |
|
|
|
@ -124,7 +163,7 @@ impl NamedJobBuilder { |
|
|
|
}) |
|
|
|
}) |
|
|
|
.collect(); |
|
|
|
.collect(); |
|
|
|
Self { |
|
|
|
Self { |
|
|
|
builder: Some(JobBuilder::from_meta(job_metas).unwrap_one()), |
|
|
|
builder: Some(JobRunner::from_meta(job_metas).unwrap_one()), |
|
|
|
job_names, |
|
|
|
job_names, |
|
|
|
results: HashMap::new(), |
|
|
|
results: HashMap::new(), |
|
|
|
} |
|
|
|
} |
|
|
|
@ -138,11 +177,11 @@ impl NamedJobBuilder { |
|
|
|
self |
|
|
|
self |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
pub fn pop_opt(&mut self, name: &'static str) -> Option<Reportable> { |
|
|
|
pub fn pop_opt(&mut self, name: &'static str) -> Option<ExecResult> { |
|
|
|
self.results.remove(name) |
|
|
|
self.results.remove(name) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
pub fn pop(&mut self, name: &'static str) -> Reportable { |
|
|
|
pub fn pop(&mut self, name: &'static str) -> ExecResult { |
|
|
|
self.pop_opt(name).unwrap() |
|
|
|
self.pop_opt(name).unwrap() |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
@ -151,8 +190,8 @@ impl NamedJobBuilder { |
|
|
|
mod tests { |
|
|
|
mod tests { |
|
|
|
use super::*; |
|
|
|
use super::*; |
|
|
|
use crate::{ |
|
|
|
use crate::{ |
|
|
|
builder::{JobBuilder, NamedJobBuilder}, |
|
|
|
|
|
|
|
models::{misc::JobType, JobMeta}, |
|
|
|
models::{misc::JobType, JobMeta}, |
|
|
|
|
|
|
|
runner::{JobRunner, NamedJobRunner}, |
|
|
|
unwrap_enum, |
|
|
|
unwrap_enum, |
|
|
|
}; |
|
|
|
}; |
|
|
|
use std::time::SystemTime; |
|
|
|
use std::time::SystemTime; |
|
|
|
@ -162,10 +201,10 @@ mod tests { |
|
|
|
#[tokio::test] |
|
|
|
#[tokio::test] |
|
|
|
async fn test_is_really_async() { |
|
|
|
async fn test_is_really_async() { |
|
|
|
const SLEEP_SECS: u64 = 1; |
|
|
|
const SLEEP_SECS: u64 = 1; |
|
|
|
let job = RawJobMeta::from_shell(format!("sleep {}", SLEEP_SECS)).unwrap(); |
|
|
|
let job = JobMeta::from_shell(format!("sleep {}", SLEEP_SECS)).unwrap(); |
|
|
|
let sleep_jobs: Vec<JobMeta> = (0..50).map(|_| job.clone()).collect(); |
|
|
|
let sleep_jobs: Vec<JobMeta> = (0..50).map(|_| job.clone()).collect(); |
|
|
|
let now = SystemTime::now(); |
|
|
|
let now = SystemTime::now(); |
|
|
|
JobBuilder::from_meta(sleep_jobs).unwrap_one().wait().await; |
|
|
|
JobRunner::from_meta(sleep_jobs).unwrap_one().wait().await; |
|
|
|
assert!(now.elapsed().unwrap().as_secs() < SLEEP_SECS + 2) |
|
|
|
assert!(now.elapsed().unwrap().as_secs() < SLEEP_SECS + 2) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -199,13 +238,16 @@ mod tests { |
|
|
|
#[case] payload: Option<&[u8]>, |
|
|
|
#[case] payload: Option<&[u8]>, |
|
|
|
#[case] expected_result: &str, |
|
|
|
#[case] expected_result: &str, |
|
|
|
) -> TestResult { |
|
|
|
) -> TestResult { |
|
|
|
let mut job = RawJobMeta::builder().with_shell(cmd); |
|
|
|
let mut job = JobMeta::builder().with_shell(cmd); |
|
|
|
if let Some(p) = payload { |
|
|
|
if let Some(p) = payload { |
|
|
|
job = job.with_payload(p); |
|
|
|
job = job.with_payload(p); |
|
|
|
} |
|
|
|
} |
|
|
|
let job = job.build().unwrap(); |
|
|
|
let job = job.build().unwrap(); |
|
|
|
let job_result = JobBuilder::from_meta(job).unwrap_one().wait_one().await; |
|
|
|
let result = JobRunner::from_meta(job) |
|
|
|
let result = unwrap_enum!(job_result, Reportable::Assigned); |
|
|
|
.unwrap_one() |
|
|
|
|
|
|
|
.wait_one() |
|
|
|
|
|
|
|
.await |
|
|
|
|
|
|
|
.unwrap(); |
|
|
|
let result = result.to_string_result(); |
|
|
|
let result = result.to_string_result(); |
|
|
|
assert_eq!(result.trim(), expected_result); |
|
|
|
assert_eq!(result.trim(), expected_result); |
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
@ -215,29 +257,25 @@ mod tests { |
|
|
|
async fn test_complex_load() -> TestResult { |
|
|
|
async fn test_complex_load() -> TestResult { |
|
|
|
const SLEEP_SECS: u64 = 1; |
|
|
|
const SLEEP_SECS: u64 = 1; |
|
|
|
let now = SystemTime::now(); |
|
|
|
let now = SystemTime::now(); |
|
|
|
let longest_job = RawJobMeta::from_shell(format!("sleep {}", SLEEP_SECS)).unwrap(); |
|
|
|
let longest_job = JobMeta::from_shell(format!("sleep {}", SLEEP_SECS)).unwrap(); |
|
|
|
let longest_job = JobBuilder::from_meta(longest_job) |
|
|
|
let longest_job = JobRunner::from_meta(longest_job).unwrap_one().spawn().await; |
|
|
|
.unwrap_one() |
|
|
|
let ls = JobRunner::from_meta(JobMeta::from_shell("ls")?) |
|
|
|
.spawn() |
|
|
|
|
|
|
|
.await; |
|
|
|
|
|
|
|
let ls = JobBuilder::from_meta(RawJobMeta::from_shell("ls")?) |
|
|
|
|
|
|
|
.unwrap_one() |
|
|
|
.unwrap_one() |
|
|
|
.wait_one() |
|
|
|
.wait_one() |
|
|
|
.await; |
|
|
|
.await |
|
|
|
let ls = unwrap_enum!(ls, Reportable::Assigned); |
|
|
|
.unwrap(); |
|
|
|
assert_eq!(ls.retcode.unwrap(), 0); |
|
|
|
assert_eq!(ls.retcode.unwrap(), 0); |
|
|
|
let folders = ls.to_string_result(); |
|
|
|
let folders = ls.to_string_result(); |
|
|
|
let subfolders_jobs: Vec<JobMeta> = folders |
|
|
|
let subfolders_jobs: Vec<JobMeta> = folders |
|
|
|
.lines() |
|
|
|
.lines() |
|
|
|
.map(|f| RawJobMeta::from_shell(format!("ls {}", f)).unwrap()) |
|
|
|
.map(|f| JobMeta::from_shell(format!("ls {}", f)).unwrap()) |
|
|
|
.collect(); |
|
|
|
.collect(); |
|
|
|
let ls_subfolders = JobBuilder::from_meta(subfolders_jobs) |
|
|
|
let ls_subfolders = JobRunner::from_meta(subfolders_jobs) |
|
|
|
.unwrap_one() |
|
|
|
.unwrap_one() |
|
|
|
.wait() |
|
|
|
.wait() |
|
|
|
.await; |
|
|
|
.await; |
|
|
|
for result in ls_subfolders { |
|
|
|
for result in ls_subfolders { |
|
|
|
let result = unwrap_enum!(result, Reportable::Assigned); |
|
|
|
assert_eq!(result.unwrap().retcode.unwrap(), 0); |
|
|
|
assert_eq!(result.retcode.unwrap(), 0); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
longest_job.wait().await; |
|
|
|
longest_job.wait().await; |
|
|
|
assert_eq!(now.elapsed().unwrap().as_secs(), SLEEP_SECS); |
|
|
|
assert_eq!(now.elapsed().unwrap().as_secs(), SLEEP_SECS); |
|
|
|
@ -263,9 +301,12 @@ mod tests { |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
#[tokio::test] |
|
|
|
#[tokio::test] |
|
|
|
async fn test_failing_shell_job() -> TestResult { |
|
|
|
async fn test_failing_shell_job() -> TestResult { |
|
|
|
let job = RawJobMeta::from_shell("lol_kek_puk")?; |
|
|
|
let job = JobMeta::from_shell("lol_kek_puk")?; |
|
|
|
let job_result = JobBuilder::from_meta(job).unwrap_one().wait_one().await; |
|
|
|
let job_result = JobRunner::from_meta(job) |
|
|
|
let job_result = unwrap_enum!(job_result, Reportable::Assigned); |
|
|
|
.unwrap_one() |
|
|
|
|
|
|
|
.wait_one() |
|
|
|
|
|
|
|
.await |
|
|
|
|
|
|
|
.unwrap(); |
|
|
|
let output = job_result.to_string_result(); |
|
|
|
let output = job_result.to_string_result(); |
|
|
|
assert!(output.contains("No such file")); |
|
|
|
assert!(output.contains("No such file")); |
|
|
|
assert!(job_result.retcode.is_none()); |
|
|
|
assert!(job_result.retcode.is_none()); |
|
|
|
@ -281,7 +322,7 @@ mod tests { |
|
|
|
#[case] payload: Option<&[u8]>, |
|
|
|
#[case] payload: Option<&[u8]>, |
|
|
|
#[case] err_str: &str, |
|
|
|
#[case] err_str: &str, |
|
|
|
) -> TestResult { |
|
|
|
) -> TestResult { |
|
|
|
let mut job = RawJobMeta::builder().with_shell(cmd); |
|
|
|
let mut job = JobMeta::builder().with_shell(cmd); |
|
|
|
if let Some(p) = payload { |
|
|
|
if let Some(p) = payload { |
|
|
|
job = job.with_payload(p); |
|
|
|
job = job.with_payload(p); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -293,17 +334,17 @@ mod tests { |
|
|
|
|
|
|
|
|
|
|
|
#[tokio::test] |
|
|
|
#[tokio::test] |
|
|
|
async fn test_different_job_types() -> TestResult { |
|
|
|
async fn test_different_job_types() -> TestResult { |
|
|
|
let mut jobs = NamedJobBuilder::from_meta(vec![ |
|
|
|
let mut jobs = NamedJobRunner::from_meta(vec![ |
|
|
|
("sleeper", RawJobMeta::from_shell("sleep 3")?), |
|
|
|
("sleeper", JobMeta::from_shell("sleep 3")?), |
|
|
|
( |
|
|
|
( |
|
|
|
"gatherer", |
|
|
|
"gatherer", |
|
|
|
RawJobMeta::builder().with_type(JobType::Manage).build()?, |
|
|
|
JobMeta::builder().with_type(JobType::Init).build()?, |
|
|
|
), |
|
|
|
), |
|
|
|
]) |
|
|
|
]) |
|
|
|
.wait() |
|
|
|
.wait() |
|
|
|
.await; |
|
|
|
.await; |
|
|
|
let gathered = jobs.pop("gatherer"); |
|
|
|
let gathered = jobs.pop("gatherer"); |
|
|
|
assert_eq!(unwrap_enum!(gathered, Reportable::Agent).alias, None); |
|
|
|
assert_eq!(gathered.unwrap().alias, None); |
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
