Read a preflight result¶

The adapter does not hand you a "preflight result" object. slurm.New runs preflight and fixes its answers for the life of the Backend. You read them through two methods:

d := b.Declarations()                    // model.Declarations, no error
caps, err := b.Capabilities(ctx, nil)    // map[model.Capability]model.Support

Through dispatch.Open, the core reads the same two methods and uses them to build a job's plan. The tutorial prints both. Capabilities and declarations lists every value and reason the adapter can give. This page is about what to do with them.

What preflight does¶

Steps 1 to 7 read the cluster on every call to slurm.New. Steps 8 and 9 write, so they run only on a backend that is not read-only, and only when there is no fresh cached result.

Any read in steps 1 to 7 that fails to run, or exits non-zero, is ErrUnreachable.

A read-only backend runs steps 1 to 7 and never writes the cache. With a matching cached result it takes Hold and AccountingHistory and the skew from it. Without one, both answers are unknown, the execution window is 0, and CallBound is worked out with a skew of 0. Such a backend makes no hold-family or requeue call, so its CallBound is informational.

Steps 1 to 7 are never cached. Because they run every time, a cluster that changes release or loses a command is noticed on the next slurm.New.

Set your poll interval from the declarations¶

The adapter has no Watcher, so a supervisor polls it. PolledLoss for state, cause and exit-code is the cluster's MinJobAge: poll at least that often, or a job can end and leave squeue between two polls. The supervisor refuses a poll interval slower than the shortest bounded window. If MinJobAge is too short for the poll you want, ask your administrator to raise it.

Act on Hold¶

With Hold not yes, Hold and Release return dispatch.ErrUnsupported with the reason, and a recovery rule whose action is hold reports the same answer from Rules.

Act on AccountingHistory¶

Inspect and Ceased read sacct only when the answer is yes, so a read-only backend with no cached probe never does.

Checking a result in your own program¶

Support.Value prints as yes, no or unknown, and Support.Source as declared, probed or catalogue. To fail fast on a cluster that cannot hold:

caps, err := b.Capabilities(ctx, nil)
if err != nil {
    return err
}

if h := caps[model.HoldCapability]; h.Value != model.Yes {
    return fmt.Errorf("holds are %s on this cluster: %s", h.Value, h.Reason)
}

Where the probe's answers are kept¶

With preflight.cacheDir set, steps 8 and 9 results are stored in one file there, named for the cluster, release and target. A result is reused only if all of these hold:

• it is younger than preflight.maxAge (24 hours by default);
• the cluster name, Slurm release and target are the same. For transport: ssh the target is the transport, host, user, port and jump host; for any other transport it is the transport's name and the host name of the machine the adapter runs on, such as local:<hostname>;
• a hash over your adapter settings and scontrol show config is the same. Only the dump's "Configuration data as of" line is ignored.

Anything else, including a file that cannot be read, is a miss, and the probe runs again. The directory must be a real directory of mode 0700 owned by you. A cache found anywhere else, or reached through a symlink, is not read. A writable slurm.New that has to write into such a directory fails with an unsafe-directory error rather than continue. Only a writable backend creates the directory, after its probe; a read-only one never does.

The cached clock skew comes with it, so it is as old as the cache. Lower maxAge if clocks on your cluster drift.

Related¶

• Capabilities and declarations
• Prepare a cluster for the adapter
• Tested Slurm versions
• Errors and error mapping