Enum Instruction 

pub enum Instruction {
    Run(RunInstruction),
    Copy(CopyInstruction),
    Add(AddInstruction),
    Env(EnvInstruction),
    Workdir(String),
    Expose(ExposeInstruction),
    Label(HashMap<String, String>),
    User(String),
    Entrypoint(ShellOrExec),
    Cmd(ShellOrExec),
    Volume(Vec<String>),
    Shell(Vec<String>),
    Arg(ArgInstruction),
    Stopsignal(String),
    Healthcheck(HealthcheckInstruction),
    Onbuild(Box<Instruction>),
}

A single Dockerfile instruction

Variants

Run(RunInstruction)

RUN instruction - executes a command and commits the result as a new layer

Copy(CopyInstruction)

COPY instruction - copies files from build context or previous stage

Add(AddInstruction)

ADD instruction - like COPY but with URL support and auto-extraction

Env(EnvInstruction)

ENV instruction - sets environment variables

Workdir(String)

WORKDIR instruction - sets the working directory

Expose(ExposeInstruction)

EXPOSE instruction - documents which ports the container listens on

Label(HashMap<String, String>)

LABEL instruction - adds metadata to the image

User(String)

USER instruction - sets the user for subsequent instructions

Entrypoint(ShellOrExec)

ENTRYPOINT instruction - configures container as executable

Cmd(ShellOrExec)

CMD instruction - provides defaults for container execution

Volume(Vec<String>)

VOLUME instruction - creates mount points

Shell(Vec<String>)

SHELL instruction - changes the default shell

Arg(ArgInstruction)

ARG instruction - defines build-time variables

Stopsignal(String)

STOPSIGNAL instruction - sets the signal for stopping the container

Healthcheck(HealthcheckInstruction)

HEALTHCHECK instruction - defines how to check container health

Onbuild(Box<Instruction>)

ONBUILD instruction - adds trigger for downstream builds

Implementations

impl Instruction

pub fn name(&self) -> &'static str

Returns the instruction name as it would appear in a Dockerfile

pub fn creates_layer(&self) -> bool

Returns true if this instruction creates a new layer

pub fn cache_key(&self) -> String

Generate a cache key for this instruction.

The key uniquely identifies the instruction and its parameters, enabling cache hit detection when combined with the base layer digest.

Returns

A 16-character hexadecimal string representing the hash of the instruction.

Example

use zlayer_builder::dockerfile::Instruction;
use zlayer_builder::dockerfile::RunInstruction;

let run = Instruction::Run(RunInstruction::shell("echo hello"));
let key = run.cache_key();
assert_eq!(key.len(), 16);

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instruction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> 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 Instruction

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 Instruction