Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Fix Devcontainer bugs/spec mismatches (#59020)

Duncan Ogilvie6aed6961556d
diff --git a/crates/dev_container/src/devcontainer_api.rs b/crates/dev_container/src/devcontainer_api.rs
index 395d50b6bd3..acd5a70b115 100644
--- a/crates/dev_container/src/devcontainer_api.rs
+++ b/crates/dev_container/src/devcontainer_api.rs
@@ -58,6 +58,8 @@ pub(crate) struct DevContainerUp {
pub(crate) extension_ids: Vec<String>,
#[serde(default)]
pub(crate) remote_env: HashMap<String, String>,
+ #[serde(default)]
+ pub(crate) started_at: Option<String>,
}
#[derive(Debug)]
diff --git a/crates/dev_container/src/devcontainer_json.rs b/crates/dev_container/src/devcontainer_json.rs
index c8573b6b9c8..38588241bdf 100644
--- a/crates/dev_container/src/devcontainer_json.rs
+++ b/crates/dev_container/src/devcontainer_json.rs
@@ -213,10 +213,10 @@ pub(crate) struct DevContainer {
user_env_probe: Option<UserEnvProbe>,
pub(crate) override_command: Option<bool>,
shutdown_action: Option<ShutdownAction>,
- init: Option<bool>,
+ pub(crate) init: Option<bool>,
pub(crate) privileged: Option<bool>,
- cap_add: Option<Vec<String>>,
- security_opt: Option<Vec<String>>,
+ pub(crate) cap_add: Option<Vec<String>>,
+ pub(crate) security_opt: Option<Vec<String>>,
#[serde(default, deserialize_with = "deserialize_mount_definitions")]
pub(crate) mounts: Option<Vec<MountDefinition>>,
pub(crate) features: Option<HashMap<String, FeatureOptions>>,
diff --git a/crates/dev_container/src/devcontainer_manifest.rs b/crates/dev_container/src/devcontainer_manifest.rs
index 3392e01da59..357ecbf1860 100644
--- a/crates/dev_container/src/devcontainer_manifest.rs
+++ b/crates/dev_container/src/devcontainer_manifest.rs
@@ -127,11 +127,11 @@ impl DevContainerManifest {
let labels = vec![
(
"devcontainer.local_folder",
- (self.local_project_directory.display()).to_string(),
+ normalize_label_path(&self.local_project_directory.display().to_string()),
),
(
"devcontainer.config_file",
- (self.config_file().display()).to_string(),
+ normalize_label_path(&self.config_file().display().to_string()),
),
];
labels
@@ -142,7 +142,15 @@ impl DevContainerManifest {
content: &str,
) -> Result<serde_json_lenient::Value, DevContainerError> {
let mut value = deserialize_devcontainer_json_to_value(content)?;
- let mut to_visit = vec![&mut value];
+ self.substitute_nonremote_vars_in_value(&mut value)?;
+ Ok(value)
+ }
+
+ fn substitute_nonremote_vars_in_value(
+ &self,
+ value: &mut serde_json_lenient::Value,
+ ) -> Result<(), DevContainerError> {
+ let mut to_visit = vec![value];
while let Some(value) = to_visit.pop() {
use serde_json_lenient::Value;
@@ -185,7 +193,7 @@ impl DevContainerManifest {
}
}
- Ok(value)
+ Ok(())
}
fn parse_nonremote_vars(&mut self) -> Result<(), DevContainerError> {
@@ -600,7 +608,12 @@ impl DevContainerManifest {
DevContainerError::ResourceFetchFailed
})?;
- let feature_manifest = FeatureManifest::new(consecutive_id, feature_dir, feature_json);
+ let feature_manifest = FeatureManifest::new(
+ consecutive_id,
+ feature_ref.to_string(),
+ feature_dir,
+ feature_json,
+ );
log::debug!("Prepared feature content for '{}'", feature_ref);
@@ -780,6 +793,7 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
fn build_merged_resources(
&self,
base_image: DockerInspect,
+ image_tag: &str,
) -> Result<DockerBuildResources, DevContainerError> {
let dev_container = match &self.config {
ConfigStatus::Deserialized(_) => {
@@ -790,14 +804,78 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
}
ConfigStatus::VariableParsed(dev_container) => dev_container,
};
- let mut mounts = dev_container.mounts.clone().unwrap_or(Vec::new());
+ let mut mounts = Vec::new();
+ let mut cap_add = Vec::new();
+ let mut security_opt = Vec::new();
+ let mut privileged = false;
+ let mut init = false;
+ let mut metadata_entries = base_image
+ .config
+ .labels
+ .metadata
+ .clone()
+ .unwrap_or_default();
+ for entry in &mut metadata_entries {
+ for value in entry.values_mut() {
+ self.substitute_nonremote_vars_in_value(value)?;
+ }
+ }
- let mut feature_mounts = self.features.iter().flat_map(|f| f.mounts()).collect();
+ for entry in &metadata_entries {
+ if let Some(serde_json_lenient::Value::Array(metadata_mounts)) = entry.get("mounts") {
+ for mount in metadata_mounts {
+ if let Some(mount) = mount_definition_from_metadata(mount) {
+ append_mount_with_target_override(&mut mounts, mount);
+ }
+ }
+ }
+ if entry.get("privileged").and_then(|value| value.as_bool()) == Some(true) {
+ privileged = true;
+ }
+ if entry.get("init").and_then(|value| value.as_bool()) == Some(true) {
+ init = true;
+ }
+ if let Some(serde_json_lenient::Value::Array(caps)) = entry.get("capAdd") {
+ for cap in caps.iter().filter_map(|cap| cap.as_str()) {
+ push_unique_string(&mut cap_add, cap);
+ }
+ }
+ if let Some(serde_json_lenient::Value::Array(opts)) = entry.get("securityOpt") {
+ for opt in opts.iter().filter_map(|opt| opt.as_str()) {
+ push_unique_string(&mut security_opt, opt);
+ }
+ }
+ }
- mounts.append(&mut feature_mounts);
+ for feature in &self.features {
+ for mount in feature.mounts() {
+ append_mount_with_target_override(&mut mounts, mount);
+ }
+ if feature.privileged() {
+ privileged = true;
+ }
+ if feature.init() {
+ init = true;
+ }
+ for cap in feature.cap_add() {
+ push_unique_string(&mut cap_add, &cap);
+ }
+ for opt in feature.security_opt() {
+ push_unique_string(&mut security_opt, &opt);
+ }
+ }
- let privileged = dev_container.privileged.unwrap_or(false)
- || self.features.iter().any(|f| f.privileged());
+ for mount in dev_container.mounts.clone().unwrap_or_default() {
+ append_mount_with_target_override(&mut mounts, mount);
+ }
+ privileged |= dev_container.privileged.unwrap_or(false);
+ init |= dev_container.init.unwrap_or(false);
+ for cap in dev_container.cap_add.clone().unwrap_or_default() {
+ push_unique_string(&mut cap_add, &cap);
+ }
+ for opt in dev_container.security_opt.clone().unwrap_or_default() {
+ push_unique_string(&mut security_opt, &opt);
+ }
let entrypoint_script = if dev_container.override_command == Some(false) {
None
@@ -818,10 +896,31 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
Some(entrypoint_script_lines.join("\n").trim().to_string())
};
+ let mut container_env = HashMap::new();
+ for entry in &metadata_entries {
+ if let Some(serde_json_lenient::Value::Object(env_map)) = entry.get("containerEnv") {
+ for (k, v) in env_map {
+ if let Some(s) = v.as_str() {
+ container_env.insert(k.clone(), s.to_string());
+ }
+ }
+ }
+ }
+ if let Some(config_env) = &dev_container.container_env {
+ for (k, v) in config_env {
+ container_env.insert(k.clone(), v.clone());
+ }
+ }
+
Ok(DockerBuildResources {
image: base_image,
+ image_tag: image_tag.to_string(),
additional_mounts: mounts,
+ container_env,
privileged,
+ init,
+ cap_add,
+ security_opt,
entrypoint_script,
})
}
@@ -837,12 +936,32 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
match dev_container.build_type() {
DevContainerBuildType::Image(base_image) => {
let built_docker_image = self.build_docker_image().await?;
+ let has_features = dev_container
+ .features
+ .as_ref()
+ .is_some_and(|features| !features.is_empty());
+ let features_image_tag = self
+ .features_build_info
+ .as_ref()
+ .map(|info| info.image_tag.as_str());
+ let uid_base_image = if has_features {
+ features_image_tag.unwrap_or(&base_image)
+ } else {
+ &base_image
+ };
+ let will_update_remote_user_uid =
+ self.should_update_remote_user_uid(&built_docker_image)?;
let built_docker_image = self
- .update_remote_user_uid(built_docker_image, &base_image)
+ .update_remote_user_uid(built_docker_image, uid_base_image)
.await?;
- let resources = self.build_merged_resources(built_docker_image)?;
+ let image_tag = if has_features || will_update_remote_user_uid {
+ features_image_tag.unwrap_or(&base_image)
+ } else {
+ &base_image
+ };
+ let resources = self.build_merged_resources(built_docker_image, image_tag)?;
Ok(DevContainerBuildResources::Docker(resources))
}
DevContainerBuildType::Dockerfile(_) => {
@@ -857,7 +976,8 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
.update_remote_user_uid(built_docker_image, &features_build_info.image_tag)
.await?;
- let resources = self.build_merged_resources(built_docker_image)?;
+ let resources = self
+ .build_merged_resources(built_docker_image, &features_build_info.image_tag)?;
Ok(DevContainerBuildResources::Docker(resources))
}
DevContainerBuildType::DockerCompose => {
@@ -899,6 +1019,10 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
let remote_env = self.runtime_remote_env(&running_container.config.env_as_map()?)?;
Ok(DevContainerUp {
+ started_at: running_container
+ .state
+ .as_ref()
+ .and_then(|state| state.started_at.clone()),
container_id: running_container.id,
remote_user,
remote_workspace_folder: remote_workspace_folder.display().to_string(),
@@ -1183,7 +1307,8 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
.update_remote_user_uid(built_service_image, built_service_image_tag)
.await?;
- let resources = self.build_merged_resources(built_service_image)?;
+ let resources =
+ self.build_merged_resources(built_service_image, built_service_image_tag)?;
let network_mode = main_service.network_mode.as_ref();
let network_mode_service = network_mode.and_then(|mode| mode.strip_prefix("service:"));
@@ -1231,17 +1356,45 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
) -> Result<DockerComposeConfig, DevContainerError> {
let mut runtime_labels = HashMap::new();
- if let Some(metadata) = &resources.image.config.labels.metadata {
- let serialized_metadata = serde_json_lenient::to_string(metadata).map_err(|e| {
- log::error!("Error serializing docker image metadata: {e}");
- DevContainerError::ContainerNotValid(resources.image.id.clone())
- })?;
+ {
+ let mut metadata_entries: Vec<serde_json_lenient::Value> = Vec::new();
- runtime_labels.insert("devcontainer.metadata".to_string(), serialized_metadata);
+ if let Some(image_metadata) = &resources.image.config.labels.metadata {
+ for entry in image_metadata {
+ if let Ok(val) = serde_json_lenient::to_value(entry) {
+ metadata_entries.push(val);
+ }
+ }
+ }
+
+ for feature in &self.features {
+ let entry = feature.build_metadata_entry();
+ if !entry.is_empty() {
+ metadata_entries.push(serde_json_lenient::Value::Object(entry));
+ }
+ }
+
+ if let Ok(substituted_json) = self.parse_nonremote_vars_for_content(&self.raw_config) {
+ let config_entry = build_devcontainer_metadata_entry(&substituted_json);
+ if !config_entry.is_empty() {
+ metadata_entries.push(serde_json_lenient::Value::Object(config_entry));
+ }
+ }
+
+ if !metadata_entries.is_empty() {
+ let serialized = serde_json_lenient::to_string(&metadata_entries).map_err(|e| {
+ log::error!("Error serializing docker image metadata: {e}");
+ DevContainerError::ContainerNotValid(resources.image.id.clone())
+ })?;
+ runtime_labels.insert(
+ "devcontainer.metadata".to_string(),
+ escape_compose_interpolation(&serialized),
+ );
+ }
}
for (k, v) in self.identifying_labels() {
- runtime_labels.insert(k.to_string(), v.to_string());
+ runtime_labels.insert(k.to_string(), escape_compose_interpolation(&v));
}
let config_volumes: HashMap<String, DockerComposeVolume> = resources
@@ -1283,13 +1436,40 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
]
});
+ let cap_add = if resources.cap_add.is_empty() {
+ None
+ } else {
+ Some(resources.cap_add)
+ };
+ let security_opt = if resources.security_opt.is_empty() {
+ None
+ } else {
+ Some(resources.security_opt)
+ };
+
+ let environment = if resources.container_env.is_empty() {
+ None
+ } else {
+ Some(
+ resources
+ .container_env
+ .into_iter()
+ .map(|(key, value)| (key, escape_compose_interpolation(&value)))
+ .collect(),
+ )
+ };
+ let privileged = resources.privileged.then_some(true);
+ let init = resources.init.then_some(true);
+
let mut main_service = DockerComposeService {
entrypoint,
- cap_add: Some(vec!["SYS_PTRACE".to_string()]),
- security_opt: Some(vec!["seccomp=unconfined".to_string()]),
+ cap_add,
+ security_opt,
labels: Some(runtime_labels),
volumes,
- privileged: Some(resources.privileged),
+ privileged,
+ init,
+ environment,
..Default::default()
};
// let mut extra_service_port_declarations: Vec<(String, DockerComposeService)> = Vec::new();
@@ -1457,6 +1637,14 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
Ok(image)
}
+ #[cfg(target_os = "windows")]
+ fn should_update_remote_user_uid(
+ &self,
+ _image: &DockerInspect,
+ ) -> Result<bool, DevContainerError> {
+ Ok(false)
+ }
+
#[cfg(target_os = "windows")]
async fn update_remote_user_uid(
&self,
@@ -1465,27 +1653,37 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || true
) -> Result<DockerInspect, DevContainerError> {
Ok(image)
}
+
+ #[cfg(not(target_os = "windows"))]
+ fn should_update_remote_user_uid(
+ &self,
+ image: &DockerInspect,
+ ) -> Result<bool, DevContainerError> {
+ if self.features_build_info.is_none() {
+ return Ok(false);
+ }
+ if self.dev_container().update_remote_user_uid == Some(false) {
+ return Ok(false);
+ }
+ let remote_user = get_remote_user_from_config(image, self)?;
+ Ok(remote_user != "root" && !remote_user.chars().all(|c| c.is_ascii_digit()))
+ }
+
#[cfg(not(target_os = "windows"))]
async fn update_remote_user_uid(
&self,
image: DockerInspect,
base_image: &str,
) -> Result<DockerInspect, DevContainerError> {
- let dev_container = self.dev_container();
-
let Some(features_build_info) = &self.features_build_info else {
return Ok(image);
};
- // updateRemoteUserUID defaults to true per the devcontainers spec
- if dev_container.update_remote_user_uid == Some(false) {
+ if !self.should_update_remote_user_uid(&image)? {
return Ok(image);
}
let remote_user = get_remote_user_from_config(&image, self)?;
- if remote_user == "root" || remote_user.chars().all(|c| c.is_ascii_digit()) {
- return Ok(image);
- }
let image_user = image
.config
@@ -1961,6 +2159,9 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
if build_resources.privileged {
command.arg("--privileged");
}
+ if build_resources.init {
+ command.arg("--init");
+ }
let run_args = match &self.dev_container().run_args {
Some(run_args) => run_args,
@@ -2006,16 +2207,48 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
command.arg(format!("{}={}", key, val));
}
- if let Some(metadata) = &build_resources.image.config.labels.metadata {
- let serialized_metadata = serde_json_lenient::to_string(metadata).map_err(|e| {
- log::error!("Problem serializing image metadata: {e}");
- DevContainerError::ContainerNotValid(build_resources.image.id.clone())
- })?;
- command.arg("-l");
- command.arg(format!(
- "{}={}",
- "devcontainer.metadata", serialized_metadata
- ));
+ {
+ let mut metadata_entries: Vec<serde_json_lenient::Value> = Vec::new();
+
+ if let Some(image_metadata) = &build_resources.image.config.labels.metadata {
+ for entry in image_metadata {
+ if let Ok(val) = serde_json_lenient::to_value(entry) {
+ metadata_entries.push(val);
+ }
+ }
+ }
+
+ for feature in &self.features {
+ let entry = feature.build_metadata_entry();
+ if !entry.is_empty() {
+ metadata_entries.push(serde_json_lenient::Value::Object(entry));
+ }
+ }
+
+ if let Ok(substituted_json) = self.parse_nonremote_vars_for_content(&self.raw_config) {
+ let config_entry = build_devcontainer_metadata_entry(&substituted_json);
+ if !config_entry.is_empty() {
+ metadata_entries.push(serde_json_lenient::Value::Object(config_entry));
+ }
+ }
+
+ if !metadata_entries.is_empty() {
+ let serialized = serde_json_lenient::to_string(&metadata_entries).map_err(|e| {
+ log::error!("Problem serializing metadata: {e}");
+ DevContainerError::ContainerNotValid(build_resources.image.id.clone())
+ })?;
+ command.arg("-l");
+ command.arg(format!("devcontainer.metadata={serialized}"));
+ }
+ }
+
+ for cap in &build_resources.cap_add {
+ command.arg("--cap-add");
+ command.arg(cap);
+ }
+ for opt in &build_resources.security_opt {
+ command.arg("--security-opt");
+ command.arg(opt);
}
if let Some(forward_ports) = &self.dev_container().forward_ports {
@@ -2031,15 +2264,20 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
command.arg(app_port);
}
+ for (key, value) in &build_resources.container_env {
+ command.arg("-e");
+ command.arg(format!("{key}={value}"));
+ }
+
if let Some(entrypoint_script) = build_resources.entrypoint_script {
command.arg("--entrypoint");
command.arg("/bin/sh");
- command.arg(&build_resources.image.id);
+ command.arg(&build_resources.image_tag);
command.arg("-c");
command.arg(entrypoint_script);
command.arg("-");
} else {
- command.arg(&build_resources.image.id);
+ command.arg(&build_resources.image_tag);
}
Ok(command)
@@ -2064,7 +2302,8 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
let devcontainer_up = self.run_dev_container(build_resources).await?;
- self.run_remote_scripts(&devcontainer_up, true).await?;
+ self.run_remote_scripts(&devcontainer_up, true, true)
+ .await?;
Ok(devcontainer_up)
}
@@ -2073,6 +2312,7 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
&self,
devcontainer_up: &DevContainerUp,
new_container: bool,
+ container_started: bool,
) -> Result<(), DevContainerError> {
let ConfigStatus::VariableParsed(config) = &self.config else {
log::error!("Config not yet parsed, cannot proceed with remote scripts");
@@ -2124,8 +2364,27 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
.await?;
}
}
- if let Some(post_start_command) = &config.post_start_command {
- for (command_name, command) in post_start_command.script_commands() {
+ }
+ if let Some(post_start_command) = &config.post_start_command {
+ let script_commands = post_start_command.script_commands();
+ if let Some(started_at) = &devcontainer_up.started_at {
+ if !script_commands.is_empty() {
+ for command_name in script_commands.keys() {
+ log::debug!("Running post start command {command_name}");
+ }
+ let script = post_start_marker_script(started_at, script_commands);
+ self.docker_client
+ .run_docker_exec(
+ &devcontainer_up.container_id,
+ &remote_folder,
+ &devcontainer_up.remote_user,
+ &devcontainer_up.remote_env,
+ Command::new(script),
+ )
+ .await?;
+ }
+ } else if container_started {
+ for (command_name, command) in script_commands {
log::debug!("Running post start command {command_name}");
self.docker_client
.run_docker_exec(
@@ -2180,11 +2439,11 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
if let Some(docker_ps) = self.check_for_existing_container().await? {
log::debug!("Dev container already found. Proceeding with it");
- let docker_inspect = self.docker_client.inspect(&docker_ps.id).await?;
+ let mut docker_inspect = self.docker_client.inspect(&docker_ps.id).await?;
- if !docker_inspect.is_running() {
+ let container_started = !docker_inspect.is_running();
+ if container_started {
log::debug!("Container not running. Will attempt to start, and then proceed");
-
match self.dev_container().build_type() {
DevContainerBuildType::DockerCompose => {
let resources = self.docker_compose_manifest().await?;
@@ -2193,6 +2452,7 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
}
_ => self.docker_client.start_container(&docker_ps.id).await?,
}
+ docker_inspect = self.docker_client.inspect(&docker_ps.id).await?;
}
let remote_user = get_remote_user_from_config(&docker_inspect, self)?;
@@ -2202,6 +2462,10 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
let remote_env = self.runtime_remote_env(&docker_inspect.config.env_as_map()?)?;
let dev_container_up = DevContainerUp {
+ started_at: docker_inspect
+ .state
+ .as_ref()
+ .and_then(|state| state.started_at.clone()),
container_id: docker_ps.id,
remote_user: remote_user,
remote_workspace_folder: remote_folder.display().to_string(),
@@ -2209,7 +2473,8 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${PATH:-\3}/g' /etc/profile || true
remote_env,
};
- self.run_remote_scripts(&dev_container_up, false).await?;
+ self.run_remote_scripts(&dev_container_up, false, container_started)
+ .await?;
Ok(Some(dev_container_up))
} else {
@@ -2472,8 +2737,13 @@ pub(crate) async fn spawn_dev_container(
#[derive(Debug)]
struct DockerBuildResources {
image: DockerInspect,
+ image_tag: String,
additional_mounts: Vec<MountDefinition>,
+ container_env: HashMap<String, String>,
privileged: bool,
+ init: bool,
+ cap_add: Vec<String>,
+ security_opt: Vec<String>,
entrypoint_script: Option<String>,
}
@@ -2988,6 +3258,180 @@ fn get_container_user_from_config(
Ok("root".to_string())
}
+fn push_unique_string(values: &mut Vec<String>, value: &str) {
+ if !values.iter().any(|existing| existing == value) {
+ values.push(value.to_string());
+ }
+}
+
+fn append_mount_with_target_override(mounts: &mut Vec<MountDefinition>, mount: MountDefinition) {
+ mounts.retain(|existing| existing.target != mount.target);
+ mounts.push(mount);
+}
+
+fn mount_definition_from_metadata(value: &serde_json_lenient::Value) -> Option<MountDefinition> {
+ match value {
+ serde_json_lenient::Value::String(value) => parse_mount_definition_string(value),
+ serde_json_lenient::Value::Object(object) => {
+ let source = object
+ .get("source")
+ .or_else(|| object.get("src"))
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let target = object
+ .get("target")
+ .or_else(|| object.get("dst"))
+ .or_else(|| object.get("destination"))
+ .and_then(|value| value.as_str())?
+ .to_string();
+ let mount_type = object
+ .get("type")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ Some(MountDefinition {
+ source,
+ target,
+ mount_type,
+ })
+ }
+ _ => None,
+ }
+}
+
+fn parse_mount_definition_string(value: &str) -> Option<MountDefinition> {
+ let mut source = None;
+ let mut target = None;
+ let mut mount_type = None;
+
+ for part in value.split(',') {
+ let Some((key, value)) = part.trim().split_once('=') else {
+ continue;
+ };
+ match key.trim() {
+ "source" | "src" => source = Some(value.trim().to_string()),
+ "target" | "dst" | "destination" => target = Some(value.trim().to_string()),
+ "type" => mount_type = Some(value.trim().to_string()),
+ _ => {}
+ }
+ }
+
+ target.map(|target| MountDefinition {
+ source,
+ target,
+ mount_type,
+ })
+}
+
+fn escape_compose_interpolation(value: &str) -> String {
+ value.replace('$', "$$")
+}
+
+fn shell_single_quote(value: &str) -> String {
+ format!("'{}'", value.replace('\'', "'\\''"))
+}
+
+fn command_to_shell_string(command: &Command) -> String {
+ let mut command_parts = vec![command.get_program().display().to_string()];
+ command_parts.extend(command.get_args().map(|arg| arg.display().to_string()));
+ command_parts.join(" ")
+}
+
+fn post_start_marker_script(started_at: &str, script_commands: HashMap<String, Command>) -> String {
+ let started_at = shell_single_quote(started_at);
+ let mut script = format!(
+ r#"user_id="$(id -u)"
+home_directory="${{HOME:-}}"
+if [ -z "$home_directory" ]; then
+ home_directory="$( (command -v getent >/dev/null 2>&1 && getent passwd "$user_id" || grep -E "^[^:]*:[^:]*:${{user_id}}:" /etc/passwd || true) | head -n 1 | cut -d: -f6)"
+fi
+if [ -z "$home_directory" ]; then
+ home_directory=/root
+fi
+marker_directory="$home_directory/.devcontainer"
+marker="$marker_directory/.postStartCommandMarker"
+started_at={started_at}
+marker_available=false
+if mkdir -p "$marker_directory"; then
+ previous_started_at="$(cat "$marker" 2>/dev/null || true)"
+ if [ "$previous_started_at" = "$started_at" ]; then
+ exit 0
+ fi
+ marker_available=true
+fi
+"#,
+ );
+ for command in script_commands.into_values() {
+ script.push_str(&command_to_shell_string(&command));
+ script.push_str("\ncommand_status=$?\n");
+ script.push_str("[ \"$command_status\" -eq 0 ] || exit \"$command_status\"\n");
+ }
+ script.push_str(
+ r#"if [ "$marker_available" = "true" ]; then
+ printf '%s' "$started_at" > "$marker" || exit $?
+fi"#,
+ );
+ script
+}
+
+fn build_devcontainer_metadata_entry(
+ raw_json: &serde_json_lenient::Value,
+) -> serde_json_lenient::Map<String, serde_json_lenient::Value> {
+ use serde_json_lenient::Value;
+ static METADATA_PROPERTIES: &[&str] = &[
+ "onCreateCommand",
+ "updateContentCommand",
+ "postCreateCommand",
+ "postStartCommand",
+ "postAttachCommand",
+ "waitFor",
+ "customizations",
+ "mounts",
+ "containerEnv",
+ "containerUser",
+ "init",
+ "privileged",
+ "capAdd",
+ "securityOpt",
+ "remoteUser",
+ "userEnvProbe",
+ "remoteEnv",
+ "overrideCommand",
+ "portsAttributes",
+ "otherPortsAttributes",
+ "forwardPorts",
+ "shutdownAction",
+ "updateRemoteUserUID",
+ "hostRequirements",
+ ];
+
+ let Value::Object(full) = raw_json else {
+ return serde_json_lenient::Map::new();
+ };
+
+ full.iter()
+ .filter(|(key, value)| METADATA_PROPERTIES.contains(&key.as_str()) && !value.is_null())
+ .map(|(key, value)| (key.clone(), value.clone()))
+ .collect()
+}
+
+fn normalize_label_path(path: &str) -> String {
+ #[cfg(not(target_os = "windows"))]
+ {
+ path.to_string()
+ }
+ #[cfg(target_os = "windows")]
+ {
+ let normalized = path.replace('/', "\\");
+ if normalized.len() >= 2 && normalized.as_bytes()[1] == b':' {
+ let mut result = normalized[..1].to_lowercase();
+ result.push_str(&normalized[1..]);
+ result
+ } else {
+ normalized
+ }
+ }
+}
+
#[cfg(test)]
mod test {
use std::{
@@ -2998,6 +3442,12 @@ mod test {
sync::{Arc, Mutex},
};
+ #[cfg(not(target_os = "windows"))]
+ use std::{
+ fs as std_fs,
+ time::{SystemTime, UNIX_EPOCH},
+ };
+
use async_trait::async_trait;
use fs::{FakeFs, Fs};
use gpui::{AppContext, TestAppContext};
@@ -3010,18 +3460,16 @@ mod test {
use serde_json_lenient::Value;
use util::{command::Command, paths::SanitizedPath};
- #[cfg(not(target_os = "windows"))]
- use crate::docker::DockerComposeServicePort;
use crate::{
DevContainerConfig, DevContainerContext,
command_json::CommandRunner,
- devcontainer_api::DevContainerError,
+ devcontainer_api::{DevContainerError, DevContainerUp},
devcontainer_json::MountDefinition,
devcontainer_manifest::{
ConfigStatus, DevContainerManifest, DockerBuildResources, DockerComposeResources,
- DockerInspect, dockerfile_inject_alias, extract_feature_id, find_primary_service,
- get_remote_user_from_config, image_from_dockerfile, is_local_feature_ref,
- resolve_compose_dockerfile,
+ DockerInspect, dockerfile_inject_alias, escape_compose_interpolation,
+ extract_feature_id, find_primary_service, get_remote_user_from_config,
+ image_from_dockerfile, is_local_feature_ref, resolve_compose_dockerfile,
},
docker::{
DockerClient, DockerComposeConfig, DockerComposeService, DockerComposeServiceBuild,
@@ -3286,8 +3734,13 @@ mod test {
mounts: None,
state: None,
},
+ image_tag: "mcr.microsoft.com/devcontainers/base:ubuntu".to_string(),
additional_mounts: vec![],
+ container_env: HashMap::new(),
privileged: false,
+ init: false,
+ cap_add: vec!["SYS_PTRACE".to_string()],
+ security_opt: vec!["seccomp=unconfined".to_string()],
entrypoint_script: Some("echo Container started\n trap \"exit 0\" 15\n exec \"$@\"\n while sleep 1 & wait $!; do :; done".to_string()),
};
let docker_run_command = devcontainer_manifest.create_docker_run_command(build_resources);
@@ -3296,10 +3749,17 @@ mod test {
let docker_run_command = docker_run_command.expect("ok");
assert_eq!(docker_run_command.get_program(), "docker");
- let expected_config_file_label = PathBuf::from(TEST_PROJECT_PATH)
+ let expected_local_folder_label = format!(
+ "devcontainer.local_folder={}",
+ super::normalize_label_path(TEST_PROJECT_PATH)
+ );
+ let expected_config_file_path = PathBuf::from(TEST_PROJECT_PATH)
.join(".devcontainer")
.join("devcontainer.json");
- let expected_config_file_label = expected_config_file_label.display();
+ let expected_config_file_label = format!(
+ "devcontainer.config_file={}",
+ super::normalize_label_path(&expected_config_file_path.display().to_string())
+ );
assert_eq!(
docker_run_command.get_args().collect::<Vec<&OsStr>>(),
vec![
@@ -3311,11 +3771,13 @@ mod test {
"type=bind,source={TEST_PROJECT_PATH},target=/workspaces/project,consistency=cached"
)),
OsStr::new("-l"),
- OsStr::new(&format!("devcontainer.local_folder={TEST_PROJECT_PATH}")),
+ OsStr::new(&expected_local_folder_label),
OsStr::new("-l"),
- OsStr::new(&format!(
- "devcontainer.config_file={expected_config_file_label}"
- )),
+ OsStr::new(&expected_config_file_label),
+ OsStr::new("--cap-add"),
+ OsStr::new("SYS_PTRACE"),
+ OsStr::new("--security-opt"),
+ OsStr::new("seccomp=unconfined"),
OsStr::new("--entrypoint"),
OsStr::new("/bin/sh"),
OsStr::new("mcr.microsoft.com/devcontainers/base:ubuntu"),
@@ -3363,7 +3825,7 @@ mod test {
};
let resources = devcontainer_manifest
- .build_merged_resources(base_image)
+ .build_merged_resources(base_image, "mcr.microsoft.com/devcontainers/base:ubuntu")
.unwrap();
assert!(
resources.entrypoint_script.is_none(),
@@ -3384,6 +3846,302 @@ mod test {
);
}
+ #[gpui::test]
+ async fn should_substitute_nonremote_variables_in_image_metadata(cx: &mut TestAppContext) {
+ let (_, mut devcontainer_manifest) = init_default_devcontainer_manifest(
+ cx,
+ r#"{
+ "image": "mcr.microsoft.com/devcontainers/base:ubuntu"
+ }"#,
+ )
+ .await
+ .unwrap();
+ devcontainer_manifest.parse_nonremote_vars().unwrap();
+
+ let metadata = serde_json_lenient::from_str(
+ r#"[
+ {
+ "id": "ghcr.io/devcontainers/features/docker-in-docker:2",
+ "mounts": [
+ {
+ "source": "dind-var-lib-docker-${devcontainerId}",
+ "target": "/var/lib/docker",
+ "type": "volume"
+ }
+ ]
+ },
+ {
+ "containerEnv": {
+ "PATH": "/custom/bin:${PATH}"
+ }
+ }
+ ]"#,
+ )
+ .unwrap();
+ let base_image = DockerInspect {
+ id: "base-image-id".to_string(),
+ config: DockerInspectConfig {
+ labels: DockerConfigLabels {
+ metadata: Some(metadata),
+ },
+ image_user: None,
+ env: vec!["PATH=/usr/local/bin:/usr/bin".to_string()],
+ },
+ mounts: None,
+ state: None,
+ };
+
+ let resources = devcontainer_manifest
+ .build_merged_resources(base_image, "mcr.microsoft.com/devcontainers/base:ubuntu")
+ .unwrap();
+
+ assert_eq!(
+ resources.additional_mounts,
+ vec![MountDefinition {
+ source: Some(format!(
+ "dind-var-lib-docker-{}",
+ devcontainer_manifest.devcontainer_id()
+ )),
+ target: "/var/lib/docker".to_string(),
+ mount_type: Some("volume".to_string()),
+ }]
+ );
+ assert_eq!(
+ resources.container_env.get("PATH").map(String::as_str),
+ Some("/custom/bin:${PATH}")
+ );
+ let persisted_mount_source = resources
+ .image
+ .config
+ .labels
+ .metadata
+ .as_ref()
+ .and_then(|entries| entries.first())
+ .and_then(|entry| entry.get("mounts"))
+ .and_then(|mounts| mounts.as_array())
+ .and_then(|mounts| mounts.first())
+ .and_then(|mount| mount.get("source"))
+ .and_then(|source| source.as_str());
+ assert_eq!(
+ persisted_mount_source,
+ Some("dind-var-lib-docker-${devcontainerId}")
+ );
+ }
+
+ #[gpui::test]
+ async fn should_use_devcontainer_cli_post_start_marker_for_started_container(
+ cx: &mut TestAppContext,
+ ) {
+ let (test_dependencies, mut devcontainer_manifest) = init_default_devcontainer_manifest(
+ cx,
+ r#"{
+ "image": "test_image:latest",
+ "postStartCommand": "echo post-start",
+ "postAttachCommand": "echo post-attach"
+ }"#,
+ )
+ .await
+ .unwrap();
+ devcontainer_manifest.parse_nonremote_vars().unwrap();
+
+ let devcontainer_up = DevContainerUp {
+ started_at: Some("2026-06-23T10:00:00Z".to_string()),
+ container_id: "container".to_string(),
+ remote_user: "root".to_string(),
+ remote_workspace_folder: "/workspaces/project".to_string(),
+ extension_ids: Vec::new(),
+ remote_env: HashMap::new(),
+ };
+
+ devcontainer_manifest
+ .run_remote_scripts(&devcontainer_up, false, false)
+ .await
+ .unwrap();
+
+ let docker_exec_commands = test_dependencies
+ .docker
+ .exec_commands_recorded
+ .lock()
+ .unwrap();
+ assert_eq!(docker_exec_commands.len(), 2);
+ let post_start_script = docker_exec_commands[0]
+ ._inner_command
+ .get_program()
+ .to_string_lossy();
+ assert!(post_start_script.contains("marker_directory=\"$home_directory/.devcontainer\""));
+ assert!(post_start_script.contains("marker=\"$marker_directory/.postStartCommandMarker\""));
+ assert!(!post_start_script.contains("/tmp/zed-devcontainer"));
+ assert!(post_start_script.contains(
+ "echo post-start\ncommand_status=$?\n[ \"$command_status\" -eq 0 ] || exit \"$command_status\""
+ ));
+ assert!(
+ post_start_script.find("echo post-start").unwrap()
+ < post_start_script.find("printf '%s'").unwrap(),
+ "postStartCommand marker must be written only after the command succeeds"
+ );
+ assert_eq!(docker_exec_commands[1]._inner_command.get_program(), "echo");
+ assert_eq!(
+ docker_exec_commands[1]
+ ._inner_command
+ .get_args()
+ .collect::<Vec<_>>(),
+ vec![OsStr::new("post-attach")]
+ );
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn post_start_marker_script_runs_command_when_marker_directory_cannot_be_created() {
+ let mut command = Command::new("echo");
+ command.arg("post-start");
+ let script = super::post_start_marker_script(
+ "2026-06-23T10:00:00Z",
+ HashMap::from([("default".to_string(), command)]),
+ );
+
+ let output = run_shell_script(&script, Path::new("/dev/null"));
+
+ assert!(
+ output.status.success(),
+ "script should not fail when marker directory cannot be created: {}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ assert_eq!(String::from_utf8_lossy(&output.stdout), "post-start\n");
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn post_start_marker_script_accepts_background_command() {
+ let home_directory = temporary_home_directory("post-start-background");
+ let started_at = "2026-06-23T10:00:00Z";
+ let marker = home_directory
+ .join(".devcontainer")
+ .join(".postStartCommandMarker");
+ let mut command = Command::new("true");
+ command.arg("&");
+ let script = super::post_start_marker_script(
+ started_at,
+ HashMap::from([("default".to_string(), command)]),
+ );
+
+ let output = run_shell_script(&script, &home_directory);
+
+ assert!(
+ output.status.success(),
+ "background command should be accepted: {}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ assert_eq!(
+ std_fs::read_to_string(&marker).expect("marker should be written"),
+ started_at
+ );
+
+ std_fs::remove_dir_all(home_directory).expect("temporary home should be removed");
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn post_start_marker_script_marks_only_after_success() {
+ let home_directory = temporary_home_directory("post-start-success");
+ let started_at = "2026-06-23T10:00:00Z";
+ let marker = home_directory
+ .join(".devcontainer")
+ .join(".postStartCommandMarker");
+ let mut command = Command::new("echo");
+ command.arg("post-start");
+ let script = super::post_start_marker_script(
+ started_at,
+ HashMap::from([("default".to_string(), command)]),
+ );
+
+ let output = run_shell_script(&script, &home_directory);
+ assert!(
+ output.status.success(),
+ "script should run successfully: {}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ assert_eq!(String::from_utf8_lossy(&output.stdout), "post-start\n");
+ assert_eq!(
+ std_fs::read_to_string(&marker).expect("marker should be written"),
+ started_at
+ );
+
+ let output = run_shell_script(&script, &home_directory);
+ assert!(
+ output.status.success(),
+ "script should skip successfully: {}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ assert_eq!(String::from_utf8_lossy(&output.stdout), "");
+
+ std_fs::remove_dir_all(home_directory).expect("temporary home should be removed");
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn post_start_marker_script_surfaces_marker_write_failure() {
+ let home_directory = temporary_home_directory("post-start-marker-write-failure");
+ let marker = home_directory
+ .join(".devcontainer")
+ .join(".postStartCommandMarker");
+ std_fs::create_dir_all(&marker).expect("marker path should be a directory");
+ let mut command = Command::new("echo");
+ command.arg("post-start");
+ let script = super::post_start_marker_script(
+ "2026-06-23T10:00:00Z",
+ HashMap::from([("default".to_string(), command)]),
+ );
+
+ let output = run_shell_script(&script, &home_directory);
+
+ assert!(!output.status.success());
+ assert_eq!(String::from_utf8_lossy(&output.stdout), "post-start\n");
+ assert!(marker.is_dir());
+
+ std_fs::remove_dir_all(home_directory).expect("temporary home should be removed");
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn post_start_marker_script_does_not_mark_after_failure() {
+ let home_directory = temporary_home_directory("post-start-failure");
+ let marker = home_directory
+ .join(".devcontainer")
+ .join(".postStartCommandMarker");
+ let script = super::post_start_marker_script(
+ "2026-06-23T10:00:00Z",
+ HashMap::from([("default".to_string(), Command::new("false"))]),
+ );
+
+ let output = run_shell_script(&script, &home_directory);
+
+ assert!(!output.status.success());
+ assert!(!marker.exists());
+
+ std_fs::remove_dir_all(home_directory).expect("temporary home should be removed");
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ fn run_shell_script(script: &str, home_directory: &Path) -> Output {
+ let mut command = Command::new("sh");
+ command.arg("-c").arg(script).env("HOME", home_directory);
+ gpui::block_on(command.output()).expect("shell should run postStartCommand marker script")
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ fn temporary_home_directory(prefix: &str) -> PathBuf {
+ let now = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .expect("system time should be after unix epoch")
+ .as_nanos();
+ let path = std::env::temp_dir().join(format!(
+ "zed-devcontainer-{prefix}-{}-{now}",
+ std::process::id()
+ ));
+ std_fs::create_dir_all(&path).expect("temporary home should be created");
+ path
+ }
+
#[gpui::test]
async fn should_find_primary_service_in_docker_compose(cx: &mut TestAppContext) {
// State where service not defined in dev container
@@ -3574,6 +4332,15 @@ mod test {
);
}
+ #[test]
+ fn escape_compose_interpolation_uses_compose_dollar_escape() {
+ assert_eq!(escape_compose_interpolation("pa$word"), "pa$$word");
+ assert_eq!(
+ escape_compose_interpolation("${containerEnv:PATH}"),
+ "$${containerEnv:PATH}"
+ );
+ }
+
#[test]
fn test_replace_environment_variables() {
let replaced = DevContainerManifest::replace_environment_variables(
@@ -4004,42 +4771,52 @@ chmod +x ./install.sh
.find(|c| c.args.get(0).is_some_and(|a| a == "run"))
.expect("found");
+ let args = &docker_run_command.args;
+
+ assert!(args.contains(&"--cap-add".to_string()));
+ assert!(args.contains(&"SYS_PTRACE".to_string()));
+ assert!(args.contains(&"--security-opt".to_string()));
+ assert!(args.contains(&"seccomp=unconfined".to_string()));
+
+ let metadata_arg = args
+ .iter()
+ .find(|a| a.starts_with("devcontainer.metadata="))
+ .unwrap();
+ let metadata_json = &metadata_arg["devcontainer.metadata=".len()..];
+ let metadata: Vec<serde_json_lenient::Value> =
+ serde_json_lenient::from_str(metadata_json).unwrap();
+ assert_eq!(metadata.len(), 4);
+ assert_eq!(metadata[0]["remoteUser"], "node");
assert_eq!(
- docker_run_command.args,
- vec![
- "run".to_string(),
- "--privileged".to_string(),
- "--cap-add=SYS_PTRACE".to_string(),
- "--sig-proxy=true".to_string(),
- "-d".to_string(),
- "--mount".to_string(),
- "type=bind,source=/path/to/local/project,target=/workspace2,consistency=cached".to_string(),
- "--mount".to_string(),
- "type=volume,source=dev-containers-cli-bashhistory,target=/home/node/commandhistory,consistency=cached".to_string(),
- "--mount".to_string(),
- "type=volume,source=dind-var-lib-docker-42dad4b4ca7b8ced,target=/var/lib/docker,consistency=cached".to_string(),
- "-l".to_string(),
- "devcontainer.local_folder=/path/to/local/project".to_string(),
- "-l".to_string(),
- "devcontainer.config_file=/path/to/local/project/.devcontainer/devcontainer.json".to_string(),
- "-l".to_string(),
- "devcontainer.metadata=[{\"remoteUser\":\"node\"}]".to_string(),
- "-p".to_string(),
- "8082:8082".to_string(),
- "-p".to_string(),
- "8083:8083".to_string(),
- "-p".to_string(),
- "8084:8084".to_string(),
- "-p".to_string(),
- "8085:8086".to_string(),
- "--entrypoint".to_string(),
- "/bin/sh".to_string(),
- "sha256:610e6cfca95280188b021774f8cf69dd6f49bdb6eebc34c5ee2010f4d51cc105".to_string(),
- "-c".to_string(),
- "echo Container started\ntrap \"exit 0\" 15\n/usr/local/share/docker-init.sh\nexec \"$@\"\nwhile sleep 1 & wait $!; do :; done".to_string(),
- "-".to_string()
- ]
+ metadata[1]["id"],
+ "ghcr.io/devcontainers/features/docker-in-docker:2"
+ );
+ assert_eq!(metadata[1]["privileged"], true);
+ assert!(metadata[1].get("containerEnv").is_none());
+ assert_eq!(metadata[2]["id"], "ghcr.io/devcontainers/features/go:1");
+ assert!(metadata[2].get("containerEnv").is_none());
+ assert!(
+ metadata[2]["capAdd"]
+ .as_array()
+ .unwrap()
+ .contains(&serde_json_lenient::Value::String("SYS_PTRACE".to_string()))
);
+ assert_eq!(metadata[3]["remoteUser"], "node");
+ assert!(metadata[3].get("onCreateCommand").is_some());
+
+ let env_args: Vec<&String> = args
+ .iter()
+ .enumerate()
+ .filter(|(_, a)| *a == "-e")
+ .filter_map(|(i, _)| args.get(i + 1))
+ .collect();
+ assert!(env_args.contains(&&"VARIABLE_VALUE=value".to_string()));
+ assert!(!env_args.contains(&&"DOCKER_BUILDKIT=1".to_string()));
+ assert!(!env_args.contains(&&"GOPATH=/go".to_string()));
+ assert!(!env_args.contains(&&"GOROOT=/usr/local/go".to_string()));
+
+ let image_arg = args.iter().find(|a| a.contains("-features")).unwrap();
+ assert!(image_arg.ends_with("-features"));
let docker_exec_commands = test_dependencies
.docker
@@ -4334,71 +5111,57 @@ ENV DOCKER_BUILDKIT=1
.expect("to be found");
let runtime_override = test_dependencies.fs.load(runtime_override).await.unwrap();
- let expected_runtime_override = DockerComposeConfig {
- name: None,
- services: HashMap::from([
- (
- "app".to_string(),
- DockerComposeService {
- entrypoint: Some(vec![
- "/bin/sh".to_string(),
- "-c".to_string(),
- "echo Container started\ntrap \"exit 0\" 15\n/usr/local/share/docker-init.sh\nexec \"$@\"\nwhile sleep 1 & wait $!; do :; done".to_string(),
- "-".to_string(),
- ]),
- cap_add: Some(vec!["SYS_PTRACE".to_string()]),
- security_opt: Some(vec!["seccomp=unconfined".to_string()]),
- privileged: Some(true),
- labels: Some(HashMap::from([
- ("devcontainer.metadata".to_string(), "[{\"remoteUser\":\"vscode\"}]".to_string()),
- ("devcontainer.local_folder".to_string(), "/path/to/local/project".to_string()),
- ("devcontainer.config_file".to_string(), "/path/to/local/project/.devcontainer/devcontainer.json".to_string())
- ])),
- volumes: vec![
- MountDefinition {
- source: Some("dind-var-lib-docker-42dad4b4ca7b8ced".to_string()),
- target: "/var/lib/docker".to_string(),
- mount_type: Some("volume".to_string())
- }
- ],
- ..Default::default()
- },
- ),
- (
- "db".to_string(),
- DockerComposeService {
- ports: vec![
- DockerComposeServicePort {
- target: "8083".to_string(),
- published: "8083".to_string(),
- ..Default::default()
- },
- DockerComposeServicePort {
- target: "5432".to_string(),
- published: "5432".to_string(),
- ..Default::default()
- },
- DockerComposeServicePort {
- target: "1234".to_string(),
- published: "1234".to_string(),
- ..Default::default()
- },
- ],
- ..Default::default()
- },
- ),
- ]),
- volumes: HashMap::from([(
- "dind-var-lib-docker-42dad4b4ca7b8ced".to_string(),
- DockerComposeVolume {
- name: Some("dind-var-lib-docker-42dad4b4ca7b8ced".to_string()),
- },
- )]),
- };
+ let runtime_config: DockerComposeConfig =
+ serde_json_lenient::from_str(&runtime_override).unwrap();
+
+ let app_service = runtime_config.services.get("app").expect("app service");
+ assert_eq!(app_service.cap_add, Some(vec!["SYS_PTRACE".to_string()]));
+ assert_eq!(
+ app_service.security_opt,
+ Some(vec!["seccomp=unconfined".to_string()])
+ );
+ assert_eq!(app_service.privileged, Some(true));
+ assert!(app_service.entrypoint.is_some());
+ let labels = app_service.labels.as_ref().unwrap();
+ assert_eq!(
+ labels.get("devcontainer.local_folder").unwrap(),
+ "/path/to/local/project"
+ );
assert_eq!(
- serde_json_lenient::from_str::<DockerComposeConfig>(&runtime_override).unwrap(),
- expected_runtime_override
+ labels.get("devcontainer.config_file").unwrap(),
+ "/path/to/local/project/.devcontainer/devcontainer.json"
+ );
+
+ let metadata_json = labels.get("devcontainer.metadata").unwrap();
+ let metadata: Vec<serde_json_lenient::Value> =
+ serde_json_lenient::from_str(metadata_json).unwrap();
+ assert!(metadata.len() >= 2);
+ assert_eq!(metadata[0]["remoteUser"], "vscode");
+ let has_dind_feature = metadata.iter().any(|e| {
+ e.get("id").and_then(|v| v.as_str())
+ == Some("ghcr.io/devcontainers/features/docker-in-docker:2")
+ });
+ assert!(
+ has_dind_feature,
+ "metadata should include docker-in-docker feature entry"
+ );
+ let has_forward_ports = metadata.iter().any(|e| e.get("forwardPorts").is_some());
+ assert!(
+ has_forward_ports,
+ "metadata should include devcontainer.json config entry with forwardPorts"
+ );
+
+ assert_eq!(app_service.volumes.len(), 1);
+ assert_eq!(app_service.volumes[0].target, "/var/lib/docker");
+
+ let db_service = runtime_config.services.get("db").expect("db service");
+ assert_eq!(db_service.ports.len(), 3);
+
+ assert!(
+ runtime_config
+ .volumes
+ .contains_key("dind-var-lib-docker-42dad4b4ca7b8ced")
)
}
@@ -6429,10 +7192,24 @@ RUN echo $RUBY_VERSION2
.to_string(),
config: DockerInspectConfig {
labels: DockerConfigLabels {
- metadata: Some(vec![HashMap::from([(
- "remoteUser".to_string(),
- Value::String("vscode".to_string()),
- )])]),
+ metadata: Some(vec![
+ HashMap::from([(
+ "remoteUser".to_string(),
+ Value::String("vscode".to_string()),
+ )]),
+ HashMap::from([
+ (
+ "capAdd".to_string(),
+ Value::Array(vec![Value::String("SYS_PTRACE".to_string())]),
+ ),
+ (
+ "securityOpt".to_string(),
+ Value::Array(vec![Value::String(
+ "seccomp=unconfined".to_string(),
+ )]),
+ ),
+ ]),
+ ]),
},
image_user: Some("root".to_string()),
env: Vec::new(),
@@ -6486,10 +7263,24 @@ RUN echo $RUBY_VERSION2
.to_string(),
config: DockerInspectConfig {
labels: DockerConfigLabels {
- metadata: Some(vec![HashMap::from([(
- "remoteUser".to_string(),
- Value::String("vscode".to_string()),
- )])]),
+ metadata: Some(vec![
+ HashMap::from([(
+ "remoteUser".to_string(),
+ Value::String("vscode".to_string()),
+ )]),
+ HashMap::from([
+ (
+ "capAdd".to_string(),
+ Value::Array(vec![Value::String("SYS_PTRACE".to_string())]),
+ ),
+ (
+ "securityOpt".to_string(),
+ Value::Array(vec![Value::String(
+ "seccomp=unconfined".to_string(),
+ )]),
+ ),
+ ]),
+ ]),
},
image_user: Some("root".to_string()),
env: Vec::new(),
diff --git a/crates/dev_container/src/docker.rs b/crates/dev_container/src/docker.rs
index 6e3e82dc76d..089564178d2 100644
--- a/crates/dev_container/src/docker.rs
+++ b/crates/dev_container/src/docker.rs
@@ -21,6 +21,8 @@ pub(crate) struct DockerPs {
#[serde(rename_all = "PascalCase")]
pub(crate) struct DockerState {
pub(crate) running: bool,
+ #[serde(default)]
+ pub(crate) started_at: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
@@ -145,6 +147,8 @@ pub(crate) struct DockerComposeService {
pub(crate) build: Option<DockerComposeServiceBuild>,
#[serde(skip_serializing_if = "Option::is_none")]
pub(crate) privileged: Option<bool>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub(crate) init: Option<bool>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
@@ -163,6 +167,12 @@ pub(crate) struct DockerComposeService {
deserialize_with = "deserialize_nullable_vec"
)]
pub(crate) command: Vec<String>,
+ #[serde(
+ skip_serializing_if = "Option::is_none",
+ default,
+ deserialize_with = "deserialize_environment"
+ )]
+ pub(crate) environment: Option<HashMap<String, String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
@@ -275,11 +285,17 @@ impl Docker {
#[async_trait]
impl DockerClient for Docker {
async fn inspect(&self, id: &String) -> Result<DockerInspect, DevContainerError> {
- // Try to pull the image, continue on failure; Image may be local only, id a reference to a running container
+ // Always try inspect first — avoid pulling unless necessary.
+ let command = self.create_docker_inspect(id);
+ match evaluate_json_command::<DockerInspect>(command).await {
+ Ok(Some(docker_inspect)) => return Ok(docker_inspect),
+ Ok(None) | Err(_) => {}
+ }
+
+ // Inspect failed — try pulling and retry.
self.pull_image(id).await.ok();
let command = self.create_docker_inspect(id);
-
let Some(docker_inspect): Option<DockerInspect> = evaluate_json_command(command).await?
else {
log::error!("Docker inspect produced no deserializable output");
@@ -373,12 +389,13 @@ impl DockerClient for Docker {
log::error!("Error running command {e} in container exec");
DevContainerError::ContainerNotValid(container_id.to_string())
})?;
+ let std_out = String::from_utf8_lossy(&output.stdout);
+ log::debug!("Command output:\n {std_out}");
if !output.status.success() {
let std_err = String::from_utf8_lossy(&output.stderr);
log::error!("Command produced a non-successful output. StdErr: {std_err}");
+ return Err(DevContainerError::DevContainerScriptsFailed);
}
- let std_out = String::from_utf8_lossy(&output.stdout);
- log::debug!("Command output:\n {std_out}");
Ok(())
}
@@ -499,6 +516,41 @@ pub(crate) trait DockerClient {
fn docker_cli(&self) -> String;
}
+fn deserialize_environment<'de, D>(
+ deserializer: D,
+) -> Result<Option<HashMap<String, String>>, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let Some(value) = Option::<serde_json_lenient::Value>::deserialize(deserializer)? else {
+ return Ok(None);
+ };
+
+ match value {
+ serde_json_lenient::Value::Object(object) => Ok(Some(
+ object
+ .into_iter()
+ .filter_map(|(key, value)| match value {
+ serde_json_lenient::Value::Null => None,
+ serde_json_lenient::Value::String(value) => Some((key, value)),
+ other => Some((key, other.to_string())),
+ })
+ .collect(),
+ )),
+ serde_json_lenient::Value::Array(values) => Ok(Some(
+ values
+ .into_iter()
+ .filter_map(|value| {
+ let value = value.as_str()?;
+ let (key, value) = value.split_once('=').unwrap_or((value, ""));
+ Some((key.to_string(), value.to_string()))
+ })
+ .collect(),
+ )),
+ _ => Ok(None),
+ }
+}
+
fn deserialize_labels<'de, D>(deserializer: D) -> Result<Option<HashMap<String, String>>, D::Error>
where
D: Deserializer<'de>,
@@ -716,6 +768,8 @@ mod test {
parse_find_process_output,
},
};
+ #[cfg(not(target_os = "windows"))]
+ use util::command::Command;
#[test]
fn use_buildkit_setting_overrides_buildx_detection() {
@@ -836,6 +890,28 @@ mod test {
)
}
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn docker_exec_returns_error_on_nonzero_exit() {
+ let docker = Docker {
+ docker_cli: "false".to_string(),
+ has_buildx: false,
+ };
+
+ let result = gpui::block_on(docker.run_docker_exec(
+ "container",
+ "/workspace",
+ "root",
+ &HashMap::new(),
+ Command::new("true"),
+ ));
+
+ assert!(matches!(
+ result,
+ Err(DevContainerError::DevContainerScriptsFailed)
+ ));
+ }
+
#[test]
fn should_deserialize_docker_ps_with_filters() {
// First, deserializes empty
@@ -1098,6 +1174,13 @@ mod test {
name: Some("custom port".to_string()),
},
],
+ environment: Some(HashMap::from([
+ ("POSTGRES_DB".to_string(), "postgres".to_string()),
+ ("POSTGRES_HOSTNAME".to_string(), "localhost".to_string()),
+ ("POSTGRES_PASSWORD".to_string(), "postgres".to_string()),
+ ("POSTGRES_PORT".to_string(), "5432".to_string()),
+ ("POSTGRES_USER".to_string(), "postgres".to_string()),
+ ])),
..Default::default()
},
),
@@ -1110,6 +1193,13 @@ mod test {
source: Some("postgres-data".to_string()),
target: "/var/lib/postgresql/data".to_string(),
}],
+ environment: Some(HashMap::from([
+ ("POSTGRES_DB".to_string(), "postgres".to_string()),
+ ("POSTGRES_HOSTNAME".to_string(), "localhost".to_string()),
+ ("POSTGRES_PASSWORD".to_string(), "postgres".to_string()),
+ ("POSTGRES_PORT".to_string(), "5432".to_string()),
+ ("POSTGRES_USER".to_string(), "postgres".to_string()),
+ ])),
..Default::default()
},
),
@@ -1181,6 +1271,44 @@ mod test {
);
}
+ #[test]
+ fn should_deserialize_compose_environment_key_only_entries() {
+ let given_config = r#"
+ {
+ "name": "devcontainer",
+ "services": {
+ "array": {
+ "image": "node:22-alpine",
+ "environment": ["USER_INPUT", "DEFINED=value"]
+ },
+ "map": {
+ "image": "node:22-alpine",
+ "environment": {
+ "USER_INPUT": null,
+ "DEFINED": "value"
+ }
+ }
+ }
+ }
+ "#;
+
+ let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
+ assert_eq!(
+ config.services.get("array").unwrap().environment,
+ Some(HashMap::from([
+ ("DEFINED".to_string(), "value".to_string()),
+ ("USER_INPUT".to_string(), "".to_string()),
+ ]))
+ );
+ assert_eq!(
+ config.services.get("map").unwrap().environment,
+ Some(HashMap::from([(
+ "DEFINED".to_string(),
+ "value".to_string()
+ )]))
+ );
+ }
+
#[test]
fn should_deserialize_compose_without_volumes() {
let given_config = r#"
diff --git a/crates/dev_container/src/features.rs b/crates/dev_container/src/features.rs
index 5c35b785852..e3b865b29a5 100644
--- a/crates/dev_container/src/features.rs
+++ b/crates/dev_container/src/features.rs
@@ -36,9 +36,18 @@ pub(crate) struct DevContainerFeatureJson {
#[serde(default)]
pub(crate) options: HashMap<String, FeatureOptionDefinition>,
pub(crate) mounts: Option<Vec<MountDefinition>>,
+ pub(crate) init: Option<bool>,
pub(crate) privileged: Option<bool>,
pub(crate) entrypoint: Option<String>,
pub(crate) container_env: Option<HashMap<String, String>>,
+ pub(crate) cap_add: Option<Vec<String>>,
+ pub(crate) security_opt: Option<Vec<String>>,
+ pub(crate) customizations: Option<Value>,
+ pub(crate) on_create_command: Option<Value>,
+ pub(crate) update_content_command: Option<Value>,
+ pub(crate) post_create_command: Option<Value>,
+ pub(crate) post_start_command: Option<Value>,
+ pub(crate) post_attach_command: Option<Value>,
}
/// A single option definition inside `devcontainer-feature.json`.
@@ -62,6 +71,7 @@ impl FeatureOptionDefinition {
#[derive(Debug, Eq, PartialEq, Default)]
pub(crate) struct FeatureManifest {
consecutive_id: String,
+ user_feature_id: String,
file_path: PathBuf,
feature_json: DevContainerFeatureJson,
}
@@ -69,11 +79,13 @@ pub(crate) struct FeatureManifest {
impl FeatureManifest {
pub(crate) fn new(
consecutive_id: String,
+ user_feature_id: String,
file_path: PathBuf,
feature_json: DevContainerFeatureJson,
) -> Self {
Self {
consecutive_id,
+ user_feature_id,
file_path,
feature_json,
}
@@ -188,6 +200,10 @@ RUN chmod -R 0755 {full_dest} \
}
}
+ pub(crate) fn init(&self) -> bool {
+ self.feature_json.init.unwrap_or(false)
+ }
+
pub(crate) fn privileged(&self) -> bool {
self.feature_json.privileged.unwrap_or(false)
}
@@ -196,9 +212,88 @@ RUN chmod -R 0755 {full_dest} \
self.feature_json.entrypoint.clone()
}
+ pub(crate) fn cap_add(&self) -> Vec<String> {
+ self.feature_json.cap_add.clone().unwrap_or_default()
+ }
+
+ pub(crate) fn security_opt(&self) -> Vec<String> {
+ self.feature_json.security_opt.clone().unwrap_or_default()
+ }
+
pub(crate) fn file_path(&self) -> PathBuf {
self.file_path.clone()
}
+
+ pub(crate) fn build_metadata_entry(
+ &self,
+ ) -> serde_json_lenient::Map<String, serde_json_lenient::Value> {
+ use serde_json_lenient::Value;
+ let mut entry = serde_json_lenient::Map::new();
+ entry.insert(
+ "id".to_string(),
+ Value::String(self.user_feature_id.clone()),
+ );
+ if let Some(true) = self.feature_json.init {
+ entry.insert("init".to_string(), Value::Bool(true));
+ }
+ if let Some(true) = self.feature_json.privileged {
+ entry.insert("privileged".to_string(), Value::Bool(true));
+ }
+ if let Some(caps) = &self.feature_json.cap_add {
+ if !caps.is_empty() {
+ entry.insert(
+ "capAdd".to_string(),
+ Value::Array(caps.iter().map(|s| Value::String(s.clone())).collect()),
+ );
+ }
+ }
+ if let Some(opts) = &self.feature_json.security_opt {
+ if !opts.is_empty() {
+ entry.insert(
+ "securityOpt".to_string(),
+ Value::Array(opts.iter().map(|s| Value::String(s.clone())).collect()),
+ );
+ }
+ }
+ if let Some(ep) = &self.feature_json.entrypoint {
+ entry.insert("entrypoint".to_string(), Value::String(ep.clone()));
+ }
+ if let Some(mounts) = &self.feature_json.mounts {
+ if !mounts.is_empty() {
+ entry.insert(
+ "mounts".to_string(),
+ Value::Array(
+ mounts
+ .iter()
+ .filter_map(|mount| serde_json_lenient::to_value(mount).ok())
+ .collect(),
+ ),
+ );
+ }
+ }
+ if let Some(customizations) = &self.feature_json.customizations {
+ if !customizations.is_null() {
+ entry.insert("customizations".to_string(), customizations.clone());
+ }
+ }
+ for (key, value) in [
+ ("onCreateCommand", &self.feature_json.on_create_command),
+ (
+ "updateContentCommand",
+ &self.feature_json.update_content_command,
+ ),
+ ("postCreateCommand", &self.feature_json.post_create_command),
+ ("postStartCommand", &self.feature_json.post_start_command),
+ ("postAttachCommand", &self.feature_json.post_attach_command),
+ ] {
+ if let Some(value) = value {
+ if !value.is_null() {
+ entry.insert(key.to_string(), value.clone());
+ }
+ }
+ }
+ entry
+ }
}
/// Parses an OCI feature reference string into its components.
diff --git a/crates/remote/src/transport/docker.rs b/crates/remote/src/transport/docker.rs
index d7996a9ad0e..8a05ddcd15c 100644
--- a/crates/remote/src/transport/docker.rs
+++ b/crates/remote/src/transport/docker.rs
@@ -127,12 +127,27 @@ impl DockerExecConnection {
}
}
+ /// Run a shell command inside the container and reliably extract its output
+ /// using unique delimiters, so that shell initialization noise (e.g. from
+ /// BASH_ENV or .bashrc) does not corrupt the result.
+ async fn run_docker_exec_delimited(&self, script: &str) -> Result<String> {
+ const MARKER: &str = "=====ZED_DELIM_7f3a9c=====";
+ let wrapped =
+ format!("printf '{MARKER}'; {script}; __exit=$?; printf '{MARKER}'; exit $__exit");
+ let output = self
+ .run_docker_exec("sh", None, &Default::default(), &["-c", &wrapped])
+ .await?;
+ let start = output.find(MARKER).map(|i| i + MARKER.len()).unwrap_or(0);
+ let end = output[start..]
+ .find(MARKER)
+ .map(|i| start + i)
+ .unwrap_or(output.len());
+ Ok(output[start..end].to_string())
+ }
+
async fn discover_shell(&self) -> String {
let default_shell = "sh";
- match self
- .run_docker_exec("sh", None, &Default::default(), &["-c", "echo $SHELL"])
- .await
- {
+ match self.run_docker_exec_delimited("echo $SHELL").await {
Ok(shell) => match shell.trim() {
"" => {
log::info!("$SHELL is not set, checking passwd for user");
@@ -147,12 +162,7 @@ impl DockerExecConnection {
}
match self
- .run_docker_exec(
- "sh",
- None,
- &Default::default(),
- &["-c", "getent passwd \"$(id -un)\" | cut -d: -f7"],
- )
+ .run_docker_exec_delimited("getent passwd \"$(id -un)\" | cut -d: -f7")
.await
{
Ok(shell) => match shell.trim() {
@@ -171,9 +181,7 @@ impl DockerExecConnection {
}
async fn check_remote_platform(&self) -> Result<RemotePlatform> {
- let uname = self
- .run_docker_exec("uname", None, &Default::default(), &["-sm"])
- .await?;
+ let uname = self.run_docker_exec_delimited("uname -sm").await?;
parse_platform(&uname)
}
@@ -338,14 +346,7 @@ impl DockerExecConnection {
}
async fn docker_user_home_dir(&self) -> Result<String> {
- let inner_program = self.shell();
- self.run_docker_exec(
- &inner_program,
- None,
- &Default::default(),
- &["-c", "echo $HOME"],
- )
- .await
+ self.run_docker_exec_delimited("echo $HOME").await
}
async fn extract_server_binary(