in src/rust/engine/src/nodes.rs [150:313]
fn run(self, context: Context) -> NodeFuture<Value> {
match &self.entry {
&rule_graph::Entry::WithDeps(rule_graph::EntryWithDeps::Inner(ref inner)) => match inner
.rule()
{
&rule_graph::Rule::Task(ref task) => context.get(Task {
params: self.params.clone(),
product: self.product,
task: task.clone(),
entry: Arc::new(self.entry.clone()),
}),
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.snapshot && input == context.core.types.path_globs =>
{
let context = context.clone();
let core = context.core.clone();
self
.select_product(&context, context.core.types.path_globs, "intrinsic")
.and_then(move |val| context.get(Snapshot(externs::key_for(val))))
.map(move |snapshot| Snapshot::store_snapshot(&core, &snapshot))
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.snapshot && input == context.core.types.url_to_fetch =>
{
let context = context.clone();
let core = context.core.clone();
self
.select_product(&context, context.core.types.url_to_fetch, "intrinsic")
.and_then(move |val| context.get(DownloadedFile(externs::key_for(val))))
.map(move |snapshot| Snapshot::store_snapshot(&core, &snapshot))
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.directory_digest
&& input == context.core.types.directories_to_merge =>
{
let request = self.select_product(
&context,
context.core.types.directories_to_merge,
"intrinsic",
);
let core = context.core.clone();
request
.and_then(move |request| {
let digests: Result<Vec<hashing::Digest>, Failure> =
externs::project_multi(&request, "directories")
.into_iter()
.map(|val| lift_digest(&val).map_err(|str| throw(&str)))
.collect();
fs::Snapshot::merge_directories(core.store(), try_future!(digests))
.map_err(|err| throw(&err))
.map(move |digest| Snapshot::store_directory(&core, &digest))
.to_boxed()
})
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.snapshot
&& input == context.core.types.directory_digest =>
{
let core = context.core.clone();
self
.select_product(&context, context.core.types.directory_digest, "intrinsic")
.and_then(|directory_digest_val| {
lift_digest(&directory_digest_val).map_err(|str| throw(&str))
})
.and_then(move |digest| {
fs::Snapshot::from_digest(context.core.store(), digest).map_err(|str| throw(&str))
})
.map(move |snapshot| Snapshot::store_snapshot(&core, &snapshot))
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.directory_digest
&& input == context.core.types.directory_with_prefix_to_strip =>
{
let request = self.select_product(
&context,
context.core.types.directory_with_prefix_to_strip,
"intrinsic",
);
let core = context.core.clone();
request
.and_then(move |request| {
let digest = lift_digest(&externs::project_ignoring_type(
&request,
"directory_digest",
))
.map_err(|str| throw(&str))?;
let prefix = externs::project_str(&request, "prefix");
Ok((digest, prefix))
})
.and_then(|(digest, prefix)| {
fs::Snapshot::strip_prefix(core.store(), digest, PathBuf::from(prefix))
.map_err(|err| throw(&err))
.map(move |digest| Snapshot::store_directory(&core, &digest))
})
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.files_content
&& input == context.core.types.directory_digest =>
{
let context = context.clone();
self
.select_product(&context, context.core.types.directory_digest, "intrinsic")
.and_then(|directory_digest_val| {
lift_digest(&directory_digest_val).map_err(|str| throw(&str))
})
.and_then(move |digest| {
context
.core
.store()
.contents_for_directory(digest)
.map_err(|str| throw(&str))
.map(move |files_content| Snapshot::store_files_content(&context, &files_content))
})
.to_boxed()
}
&rule_graph::Rule::Intrinsic(Intrinsic { product, input })
if product == context.core.types.process_result
&& input == context.core.types.process_request =>
{
let context = context.clone();
let core = context.core.clone();
self
.select_product(&context, context.core.types.process_request, "intrinsic")
.and_then(|request| {
ExecuteProcess::lift(&request)
.map_err(|str| throw(&format!("Error lifting ExecuteProcess: {}", str)))
})
.and_then(move |process_request| context.get(process_request))
.map(move |result| {
externs::unsafe_call(
&core.types.construct_process_result,
&[
externs::store_bytes(&result.0.stdout),
externs::store_bytes(&result.0.stderr),
externs::store_i64(result.0.exit_code.into()),
Snapshot::store_directory(&core, &result.0.output_directory),
],
)
})
.to_boxed()
}
&rule_graph::Rule::Intrinsic(i) => panic!("Unrecognized intrinsic: {:?}", i),
},
&rule_graph::Entry::Param(type_id) => {
if let Some(key) = self.params.find(type_id) {
ok(externs::val_for(key))
} else {
err(throw(&format!(
"Expected a Param of type {} to be present.",
type_id
)))
}
}
&rule_graph::Entry::WithDeps(rule_graph::EntryWithDeps::Root(_)) => {
panic!("Not a runtime-executable entry! {:?}", self.entry)
}
}
}