Enum Instruction 

pub enum Instruction {
    Add {
        checksum: Option<String>,
        chown: Option<String>,
        chmod: Option<String>,
        link: Option<String>,
        sources: Vec<String>,
        destination: String,
    },
    Arg(BTreeMap<String, Option<String>>),
    Cmd(Vec<String>),
    Comment(String),
    Copy {
        from: Option<String>,
        chown: Option<String>,
        chmod: Option<String>,
        link: Option<String>,
        sources: Vec<String>,
        destination: String,
    },
    Empty {},
    Entrypoint(Vec<String>),
    Env(BTreeMap<String, String>),
    Expose {
        ports: Vec<String>,
    },
    From {
        platform: Option<String>,
        image: String,
        alias: Option<String>,
    },
    Label(BTreeMap<String, String>),
    Run {
        mount: Option<String>,
        network: Option<String>,
        security: Option<String>,
        command: Vec<String>,
        heredoc: Option<Vec<String>>,
    },
    Shell(Vec<String>),
    Stopsignal {
        signal: String,
    },
    User {
        user: String,
        group: Option<String>,
    },
    Volume {
        mounts: Vec<String>,
    },
    Workdir {
        path: String,
    },
}

This enum represents available instructions in a Dockerfile and their associated data.

Variants

Add

ADD Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let add = Instruction::Add {
    checksum: None,
    chown: None,
    chmod: None,
    link: None,
    sources: Vec::from([String::from("source1"), String::from("source2")]),
    destination: String::from("/destination"),
};

Fields

checksum: Option<String>

chown: Option<String>

chmod: Option<String>

link: Option<String>

sources: Vec<String>

destination: String

Arg(BTreeMap<String, Option<String>>)

ARG Dockerfile instruction.

Example

use std::collections::BTreeMap;

use dockerfile_parser_rs::Instruction;

let arg = Instruction::Arg(BTreeMap::from([
    (String::from("ARG1"), Some(String::from("value1"))),
    (String::from("ARG2"), None),
]));

Cmd(Vec<String>)

CMD Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let cmd = Instruction::Cmd(Vec::from([
    String::from("echo"),
    String::from("Hello, World!"),
]));

Comment(String)

A comment.

Example

use dockerfile_parser_rs::Instruction;

let comment = Instruction::Comment(String::from("# This is a comment"));

Copy

COPY Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let copy = Instruction::Copy {
    from: Some(String::from("builder")),
    chown: None,
    chmod: None,
    link: None,
    sources: Vec::from([String::from("source1"), String::from("source2")]),
    destination: String::from("/destination"),
};

Fields

from: Option<String>

chown: Option<String>

chmod: Option<String>

link: Option<String>

sources: Vec<String>

destination: String

Empty

An empty line.

Example

use dockerfile_parser_rs::Instruction;

let empty = Instruction::Empty {};

Entrypoint(Vec<String>)

ENTRYPOINT Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let entrypoint = Instruction::Entrypoint(Vec::from([String::from("entrypoint.sh")]));

Env(BTreeMap<String, String>)

ENV Dockerfile instruction.

Example

use std::collections::BTreeMap;

use dockerfile_parser_rs::Instruction;

let env = Instruction::Env(BTreeMap::from([
    (String::from("ENV1"), String::from("value1")),
    (String::from("ENV2"), String::from("value2")),
]));

Expose

EXPOSE Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let expose = Instruction::Expose {
    ports: Vec::from([String::from("8080")]),
};

Fields

ports: Vec<String>

From

FROM Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let from = Instruction::From {
    platform: Some(String::from("linux/amd64")),
    image: String::from("docker.io/library/fedora:latest"),
    alias: Some(String::from("builder")),
};

Fields

platform: Option<String>

image: String

alias: Option<String>

Label(BTreeMap<String, String>)

LABEL Dockerfile instruction.

Example

use std::collections::BTreeMap;

use dockerfile_parser_rs::Instruction;

let label = Instruction::Label(BTreeMap::from([
    (String::from("version"), String::from("1.0")),
    (String::from("maintainer"), String::from("John Doe")),
]));

Run

RUN Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let run = Instruction::Run {
    mount: None,
    network: None,
    security: None,
    command: Vec::from([String::from("<<EOF")]),
    heredoc: Some(Vec::from([
        String::from("dnf upgrade -y"),
        String::from("dnf install -y rustup"),
        String::from("EOF"),
    ])),
};

Fields

mount: Option<String>

network: Option<String>

security: Option<String>

command: Vec<String>

heredoc: Option<Vec<String>>

Shell(Vec<String>)

SHELL Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let shell = Instruction::Shell(Vec::from([String::from("/bin/sh"), String::from("-c")]));

Stopsignal

STOPSIGNAL Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let stopsignal = Instruction::Stopsignal {
    signal: String::from("SIGTERM"),
};

Fields

signal: String

User

USER Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let user = Instruction::User {
    user: String::from("1001"),
    group: None,
};

Fields

user: String

group: Option<String>

Volume

VOLUME Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let volume = Instruction::Volume {
    mounts: Vec::from([String::from("/data")]),
};

Fields

mounts: Vec<String>

Workdir

WORKDIR Dockerfile instruction.

Example

use dockerfile_parser_rs::Instruction;

let workdir = Instruction::Workdir {
    path: String::from("/app"),
};

Fields

path: String

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 Display for Instruction

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

Formats the value using the given formatter.

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 Eq for Instruction

impl StructuralPartialEq for Instruction