use std::collections::HashMap;
use std::iter::{empty, once};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use buildkit_proto::pb::{
self, op::Op, ExecOp, Input, MountType, NetMode, OpMetadata, SecurityMode,
};
use either::Either;
use super::context::Context;
use super::mount::Mount;
use crate::ops::{MultiBorrowedOutput, MultiOwnedOutput, OperationBuilder};
use crate::serialization::{Context as SerializationCtx, Node, Operation, OperationId, Result};
use crate::utils::{OperationOutput, OutputIdx};
#[derive(Debug, Clone)]
pub struct Command<'a> {
id: OperationId,
context: Context,
root_mount: Option<Mount<'a, PathBuf>>,
other_mounts: Vec<Mount<'a, PathBuf>>,
description: HashMap<String, String>,
caps: HashMap<String, bool>,
ignore_cache: bool,
}
impl<'a> Command<'a> {
pub fn run<S>(name: S) -> Self
where
S: Into<String>,
{
Self {
id: OperationId::default(),
context: Context::new(name),
root_mount: None,
other_mounts: vec![],
description: Default::default(),
caps: Default::default(),
ignore_cache: false,
}
}
pub fn args<A, S>(mut self, args: A) -> Self
where
A: IntoIterator<Item = S>,
S: AsRef<str>,
{
self.context.args = args.into_iter().map(|item| item.as_ref().into()).collect();
self
}
pub fn env<S, Q>(mut self, name: S, value: Q) -> Self
where
S: AsRef<str>,
Q: AsRef<str>,
{
let env = format!("{}={}", name.as_ref(), value.as_ref());
self.context.env.push(env);
self
}
pub fn env_iter<I, S, Q>(mut self, iter: I) -> Self
where
I: IntoIterator<Item = (S, Q)>,
S: AsRef<str>,
Q: AsRef<str>,
{
for (name, value) in iter.into_iter() {
let env = format!("{}={}", name.as_ref(), value.as_ref());
self.context.env.push(env);
}
self
}
pub fn cwd<P>(mut self, path: P) -> Self
where
P: Into<PathBuf>,
{
self.context.cwd = path.into();
self
}
pub fn user<S>(mut self, user: S) -> Self
where
S: Into<String>,
{
self.context.user = user.into();
self
}
pub fn mount<P>(mut self, mount: Mount<'a, P>) -> Self
where
P: AsRef<Path>,
{
match mount {
Mount::Layer(..) | Mount::ReadOnlyLayer(..) | Mount::Scratch(..) => {
self.caps.insert("exec.mount.bind".into(), true);
}
Mount::ReadOnlySelector(..) => {
self.caps.insert("exec.mount.bind".into(), true);
self.caps.insert("exec.mount.selector".into(), true);
}
Mount::SharedCache(..) => {
self.caps.insert("exec.mount.cache".into(), true);
self.caps.insert("exec.mount.cache.sharing".into(), true);
}
Mount::OptionalSshAgent(..) => {
self.caps.insert("exec.mount.ssh".into(), true);
}
}
if mount.is_root() {
self.root_mount = Some(mount.into_owned());
} else {
self.other_mounts.push(mount.into_owned());
}
self
}
}
impl<'a, 'b: 'a> MultiBorrowedOutput<'b> for Command<'b> {
fn output(&'b self, index: u32) -> OperationOutput<'b> {
OperationOutput::borrowed(self, OutputIdx(index))
}
}
impl<'a> MultiOwnedOutput<'a> for Arc<Command<'a>> {
fn output(&self, index: u32) -> OperationOutput<'a> {
OperationOutput::owned(self.clone(), OutputIdx(index))
}
}
impl<'a> OperationBuilder<'a> for Command<'a> {
fn custom_name<S>(mut self, name: S) -> Self
where
S: Into<String>,
{
self.description
.insert("llb.customname".into(), name.into());
self
}
fn ignore_cache(mut self, ignore: bool) -> Self {
self.ignore_cache = ignore;
self
}
}
impl<'a> Operation for Command<'a> {
fn id(&self) -> &OperationId {
&self.id
}
fn serialize(&self, cx: &mut SerializationCtx) -> Result<Node> {
let (inputs, mounts): (Vec<_>, Vec<_>) = {
let mut last_input_index = 0;
self.root_mount
.as_ref()
.into_iter()
.chain(self.other_mounts.iter())
.map(|mount| {
let inner_mount = match mount {
Mount::ReadOnlyLayer(_, destination) => pb::Mount {
input: last_input_index,
dest: destination.to_string_lossy().into(),
output: -1,
readonly: true,
mount_type: MountType::Bind as i32,
..Default::default()
},
Mount::ReadOnlySelector(_, destination, source) => pb::Mount {
input: last_input_index,
dest: destination.to_string_lossy().into(),
output: -1,
readonly: true,
selector: source.to_string_lossy().into(),
mount_type: MountType::Bind as i32,
..Default::default()
},
Mount::Layer(output, _, path) => pb::Mount {
input: last_input_index,
dest: path.to_string_lossy().into(),
output: output.into(),
mount_type: MountType::Bind as i32,
..Default::default()
},
Mount::Scratch(output, path) => {
let mount = pb::Mount {
input: -1,
dest: path.to_string_lossy().into(),
output: output.into(),
mount_type: MountType::Bind as i32,
..Default::default()
};
return (Either::Right(empty()), mount);
}
Mount::SharedCache(path) => {
use buildkit_proto::pb::{CacheOpt, CacheSharingOpt};
let mount = pb::Mount {
input: -1,
dest: path.to_string_lossy().into(),
output: -1,
mount_type: MountType::Cache as i32,
cache_opt: Some(CacheOpt {
id: path.display().to_string(),
sharing: CacheSharingOpt::Shared as i32,
}),
..Default::default()
};
return (Either::Right(empty()), mount);
}
Mount::OptionalSshAgent(path) => {
use buildkit_proto::pb::SshOpt;
let mount = pb::Mount {
input: -1,
dest: path.to_string_lossy().into(),
output: -1,
mount_type: MountType::Ssh as i32,
ssh_opt: Some(SshOpt {
mode: 0o600,
optional: true,
..Default::default()
}),
..Default::default()
};
return (Either::Right(empty()), mount);
}
};
let input = match mount {
Mount::ReadOnlyLayer(input, ..) => input,
Mount::ReadOnlySelector(input, ..) => input,
Mount::Layer(_, input, ..) => input,
Mount::SharedCache(..) => {
unreachable!();
}
Mount::Scratch(..) => {
unreachable!();
}
Mount::OptionalSshAgent(..) => {
unreachable!();
}
};
let serialized = cx.register(input.operation()).unwrap();
let input = Input {
digest: serialized.digest.clone(),
index: input.output().into(),
};
last_input_index += 1;
(Either::Left(once(input)), inner_mount)
})
.unzip()
};
let head = pb::Op {
op: Some(Op::Exec(ExecOp {
mounts,
network: NetMode::Unset.into(),
security: SecurityMode::Sandbox.into(),
meta: Some(self.context.clone().into()),
})),
inputs: inputs.into_iter().flatten().collect(),
..Default::default()
};
let metadata = OpMetadata {
description: self.description.clone(),
caps: self.caps.clone(),
ignore_cache: self.ignore_cache,
..Default::default()
};
Ok(Node::new(head, metadata))
}
}