Lifecycle

dedalus machines list

machines = client.machines.list()

const machines = await client.machines.list();

machines, _ := client.Machines.List(ctx, dedalus.MachineListParams{})
fmt.Println(len(machines.Items))

dedalus machines retrieve --machine-id <machine_id>

dm = client.machines.retrieve(machine_id="<machine_id>")

const dm = await client.machines.retrieve({ machine_id: "<machine_id>" });

dm, _ := client.Machines.Get(ctx, dedalus.MachineGetParams{
    MachineID: machineID,
})
fmt.Println(dm.Status.Phase)

dedalus machines watch --machine-id <machine_id>

import json

with client.machines.with_streaming_response.watch(machine_id="<machine_id>") as resp:
    for line in resp.iter_lines():
        if line.startswith("data:"):
            payload = json.loads(line[5:])
            print(payload["status"]["phase"])

const stream = await client.machines.watch({ machine_id: "<machine_id>" });
for await (const evt of stream) {
  console.log(evt.status.phase);
}

stream := client.Machines.WatchStreaming(ctx, dedalus.MachineWatchParams{
    MachineID: machineID,
})
for stream.Next() {
    fmt.Println(stream.Current().Status.Phase)
}

dedalus machines update --machine-id <machine_id> --autosleep 15m

client.machines.update(
    machine_id="<machine_id>",
    autosleep="15m",
)

await client.machines.update({
  machine_id: "<machine_id>",
  autosleep: "15m",
});

dm, _ := client.Machines.Update(ctx, dedalus.MachineUpdateParams{
    MachineID: machineID,
    UpdateParams: dedalus.UpdateParams{
        Autosleep: dedalus.String("15m"),
    },
})
fmt.Println(dm.AutosleepSeconds)

dedalus machines sleep --machine-id <machine_id>

client.machines.sleep(machine_id="<machine_id>")

await client.machines.sleep({ machine_id: "<machine_id>" });

client.Machines.Sleep(ctx, dedalus.MachineSleepParams{
    MachineID: machineID,
})

dedalus machines wake --machine-id <machine_id>

client.machines.wake(machine_id="<machine_id>")

await client.machines.wake({ machine_id: "<machine_id>" });

client.Machines.Wake(ctx, dedalus.MachineWakeParams{
    MachineID: machineID,
})

dedalus machines delete --machine-id <machine_id>

client.machines.delete(machine_id="<machine_id>")

await client.machines.delete({ machine_id: "<machine_id>" });

client.Machines.Delete(ctx, dedalus.MachineDeleteParams{
    MachineID: machineID,
})