distrobox-enter

#!/bin/sh
# POSIX
# Expected env variables:
#	HOME
#	USER
#	SHELL

trap '[ "$?" -ne 0 ] && printf "\nAn error occurred\n"' EXIT

# Defaults
container_command="${SHELL:-"bash"} -l"
container_name="fedora-toolbox-35"
headless=0
verbose=0
version="distrobox_version_placeholder"

# Print usage to stdout.
# Arguments:
#   None
# Outputs:
#   print usage with examples.
show_help() {
	cat <<EOF

distrobox version: ${version}

distrobox-enter takes care of entering the container with the name specified.
Default command executed is your SHELL, buf you can specify different shells or
entire commands to execute.
If using it inside a script, an application or a service, you can specify the
--headless mode to disable tty and interactivity.

Usage:

	distrobox-enter --name fedora-toolbox-35 -- bash -l

Options:

	--name/-n:		name for the distrobox						default: fedora-toolbox-35
	--/-e:			end arguments execute the rest as command to execute at login	default: bash -l
	--headless/-H:		do not instantiate a tty
	--help/-h:		show this message
	--verbose/-v:		show more verbosity
	--version/-V:		show version
EOF
}

# Parse arguments
while :; do
	case $1 in
	-h | --help)
		# Call a "show_help" function to display a synopsis, then exit.
		show_help
		exit 0
		;;
	-v | --verbose)
		shift
		verbose=1
		;;
	-H | --headless)
		shift
		headless=1
		;;
	-V | --version)
		printf "distrobox: %s\n" "${version}"
		exit 0
		;;
	-n | --name)
		if [ -n "$2" ]; then
			container_name="$2"
			shift
			shift
		fi
		;;
	-e | --exec | --)
		shift
		container_command=$*
		break
		;;
	*) # Default case: If no more options then break out of the loop.
		break ;;
	esac
done

set -o errexit
set -o nounset
# set verbosity
if [ "${verbose}" -ne 0 ]; then
	set -o xtrace
fi

# We depend on a container manager let's be sure we have it
# First we use podman, else docker
container_manager="podman"
if ! command -v podman >/dev/null; then
	container_manager="docker"
	if ! command -v docker >/dev/null; then
		printf >&2 "Missing dependency: we need a container manager\n."
		printf >&2 "Please install one of podman or docker.\n"
		exit 127
	fi
fi

# Generate Podman or Docker command to execute.
# Arguments:
#   None
# Outputs:
#   prints the podman or docker command to enter the distrobox container
generate_command() {
	result_command="${container_manager}"
	# add  verbose if -v is specified
	if [ "${verbose}" -ne 0 ]; then
		result_command="${result_command} --log-level debug"
	fi
	result_command="${result_command} exec"
	result_command="${result_command}
		--user=${USER}"

	if [ "${headless}" -eq 0 ]; then
		result_command="${result_command}
			--interactive
			--tty"
	fi
	# Entering container using our user and workdir.
	# Start container from working directory. Else default to home. Else do /.
	# pass distrobox-enter path, it will be used in the distrobox-export tool.
	result_command="${result_command}
		--workdir=${PWD:-${HOME:-"/"}}
		--env=DISTROBOX_ENTER_PATH=$(command -v distrobox-enter)"

	# Loop through all the environment vars
	# and export them to the container.
	set +o xtrace
	# disable logging fot this snippet, or it will be too talkative.
	for i in $(printenv | grep '=' | grep -v ' ' | grep -v '"'); do
		result_command="${result_command} --env=\"${i}\""
	done
	# re-enable logging if it was enabled previously.
	if [ "${verbose}" -ne 0 ]; then
		set -o xtrace
	fi

	# Run selected container with specified command.
	result_command="${result_command} ${container_name} ${container_command}"

	# Return generated command.
	printf "%s" "${result_command}"
}

# Inspect the container we're working with.
container_status="$("${container_manager}" inspect --type container "${container_name}" --format '{{.State.Status}}')"
container_exists="$?"
# Does the container exists? check if inspect reported errors
if [ "${container_exists}" -gt 0 ]; then
	# If not, prompt to create it first
	printf >&2 "Cannot find container %s, does it exist?\n" "${container_name}"
	printf >&2 "\nTry running first:\n"
	printf >&2 "\tdistrobox-create --name <name-of-container> --image <remote>/<docker>:<tag>\n"
	exit 1
fi

# If the container is not already running, we need to start if first
if [ "${container_status}" != "running" ]; then
	# If container is not running, start it first
	# Here, we save the timestamp before launching the start command, so we can
	# be sure we're working with this very same session of logs later.
	log_timestamp="$(date +%FT%T.%N%:z)"
	"${container_manager}" start "${container_name}" >/dev/null

	printf >&2 "Starting container %s\n" "${container_name}"
	printf >&2 "run this command to follow along:\n"
	printf >&2 "\t%s logs -f %s\n" "${container_manager}" "${container_name}"

	# Wait for container to start successfully.
	# We will probe the container logs every 1s to check if we have either:
	# Error or container_setup_done
	#
	# In the end, print eventual Warnings that occurred.
	while :; do
		container_manager_log="$("${container_manager}" logs -t \
			--since "${log_timestamp}" \
			"${container_name}" 2>/dev/null)"
		case "${container_manager_log}" in
		*"Error"*)
			printf >&2 "%s\n" "${container_manager_log}"
			exit 1
			;;
		*"container_setup_done"*)
			break
			;;
		*)
			printf >&2 "."
			sleep 1
			;;
		esac
	done
	printf >&2 "\ndone!\n"
	# Print eventual warnings in the log.
	"${container_manager}" logs -t \
		--since "${log_timestamp}" \
		"${container_name}" 2>/dev/null | grep "Warning" >&2 || :
fi

# Generate the exec command and run it
cmd="$(generate_command)"
# shellcheck disable=SC2086
eval ${cmd}