Enum Executor 

pub enum Executor {
    Apptainer,
    Docker,
    Podman,
    Sandbox,
    Shell,
    Ssh,
    Kubernetes,
    VirtualMachine,
    Other(String),
}

The “engine” or “execution method” that determines where and how to run (e.g., “execute”) code

Note

At a minimum, choosing an executor also determines level of isolation and security for code execution.

Variants

Apptainer

Simplifies the creation and execution of containers, ensuring software components are encapsulated for portability and reproducibility

Note

Formerly Singularity

Docker

Container engine and ecosystem for building, running, and managing containers

See https://www.docker.com/products/docker-desktop for more information

Podman

Daemonless, open-source container engine for building, running, and managing containers, with a Docker-like command line

Note

Podman is rootless by default

See https://podman.io/ for more information

Sandbox

Secure execution environment that leverages technology other than containerization to achieve isolation

Shell

Local command-line interface that interprets and runs commands for the operating system directly

Ssh

Secure Shell (SSH) protocol for remote command execution

Kubernetes

Portable, extensible, open source platform for managing containerized workloads and services that facilitate both declarative configuration and automation

See https://kubernetes.io/ for more information

VirtualMachine

Software-based computers that run an operating system inside another host system, with stronger isolation than containers

Examples

• Oracle VirtualBox
• Vagrant
• Amazon Firecracker

Other(String)

Custom or unspecified execution method

Implementations

impl Executor

pub fn default_gitlab_runner_config_directory() -> &'static str

Returns the default configuration directory on host for GitLab runners based on the operating system.

pub fn command(&self) -> Option<&str>

Returns the OS binary name used to manage this executor.

Returns "docker", "podman", "apptainer" for container-based executors, or "gitlab-runner" for all others.

pub fn gitlab_runner_type(&self) -> &str

Returns the value passed to gitlab-runner register --executor.

pub fn socket(&self) -> Option<String>

Returns the path to the socket file used to manage this executor, if applicable.

Trait Implementations

impl AsRef<str> for Executor

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Executor

fn clone(&self) -> Executor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Executor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Executor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Executor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Executor

impl From<&str> for Executor

fn from(value: &str) -> Self

Parses a string into a Executor value

impl From<Executor> for OsString

fn from(value: Executor) -> Self

Converts to this type from the input type.

impl From<Executor> for String

fn from(value: Executor) -> Self

Converts to this type from the input type.

impl JsonSchema for Executor

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Executor

fn eq(&self, other: &Executor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Executor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Executor