Enum Step 

#[non_exhaustive]
pub enum Step {
    Run {
        script: ProjectPath,
        creates: Option<AbsPath>,
    },
    Copy(Copy),
    Packages(Vec<Package>),
    Reboot,
    Playbook(ProjectPath),
    Repository(Repository),
    File(FileStep),
    Template(Template),
    User(UserStep),
    Group(GroupStep),
    Service(Service),
    Command(CommandStep),
    Firewall(Firewall),
}

One step of the portable recipe. Steps install and configure: they run as root from the project copy at /opt/isoloom, with no network to the other machines and no inputs or secrets (on containers they run at image build time). What needs those goes in setup.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Run

A project script (.sh, or .ps1 on Windows), skipped when creates exists.

Fields

script: ProjectPath

The script.

creates: Option<AbsPath>

A path whose existence means the step already ran.

Copy(Copy)

A project file or folder copied into the machine.

Packages(Vec<Package>)

Packages installed with the OS’s own installer (Windows features on Windows), never empty.

Reboot

The machine restarts, and the next step runs once it is back (no container form).

Playbook(ProjectPath)

An Ansible playbook of the project, run in the machine (no container form in 1.0).

Repository(Repository)

A vendor’s package repository, its key pinned.

File(FileStep)

A folder, a removal, a link or a pinned download.

Template(Template)

A project file with its placeholders filled in.

User(UserStep)

A local user.

Group(GroupStep)

A local group.

Service(Service)

A daemon: enabled and started on VMs, the container’s process in containers.

Command(CommandStep)

A command run once, behind its guard.

Firewall(Firewall)

Ports opened in the OS’s own firewall.

Implementations

impl Step

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

The step’s kind, as its key is written (run, copy, reboot).

pub fn container_refusal(&self) -> Option<&'static str>

Why the step has no container form, when it has none.

Trait Implementations

impl Clone for Step

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Step

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Step

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Step

impl Hash for Step

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for Step

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

The name of the generated JSON Schema.

fn json_schema(g: &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.

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

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

impl PartialEq for Step

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Step