62 lines
3.1 KiB
Markdown
62 lines
3.1 KiB
Markdown
# Failover Manager for SE scripts
|
|
|
|
This mixin allows multiple Programmable Blocks to coordinate with each other so only one copy of the script is running at a time; all but one block act as backup nodes that will be automatically activated (in priority order) in the event the active node goes offline.
|
|
|
|
## Prerequisites
|
|
|
|
* Everything assumes you're using [MDK2](TODO). Using this without MDK is possible, but is outside the scope of this documentation. (You probably just need to copy everything inside the `partial class Program` block for each mixin you're using into your own script, but I can't guarantee support for problems you encounter)
|
|
* This requires my Console mixin as well. If you don't want to use that mixin's full functionality, you can use an EchoConsole (example below).
|
|
* If you aren't using MyIni to configure your script's blocks, you can also just pass `new MyIni()` and avoid instantiating an entire property
|
|
|
|
## Usage
|
|
|
|
This code is designed to be as drop-in as possible once you meet the prerequisites above. Usage should look something like this:
|
|
|
|
```
|
|
public partial class Program : MyGridProgram
|
|
public MyIni Ini { get; } = new MyIni();
|
|
public IConsole Console { get; private set; }
|
|
|
|
private FailoverManager _failover;
|
|
|
|
public Program() {
|
|
Console = new MainConsole(this, "Script Name");
|
|
_failover = new FailoverManager(this, Console, Ini);
|
|
|
|
// alternate instantiation with Stub Console and fresh MyIni instance.
|
|
// If you do it this way, you don't need the `Ini` or `Console` properties above.
|
|
// _failover = new FailoverManager(this, new EchoConsole(this), new MyIni());
|
|
|
|
// The script *must* start out with periodic updates, even if it is
|
|
// a script that's only triggered conditionally (though in that case),
|
|
// see caveats.
|
|
Runtime.UpdateFrequency = UpdateFrequency.Update100;
|
|
|
|
// ... script initialization happens here
|
|
}
|
|
|
|
public void Main(string argument, UpdateType updateSource) {
|
|
// This basically instructs the script to "go back to sleep"
|
|
// if it isn't the active node.
|
|
if (_failover.ActiveCheck == FailoverState.Standby) return;
|
|
|
|
// If you need more complicated "warm-up" logic when your script
|
|
// becomes active, (for example, changing the update frequency) you can use this.
|
|
// This statement will only be true once, when the script first takes over control.
|
|
//
|
|
// This is optional and depends on your use case.
|
|
if (_failover.ActiveCheck.HasFlag(FailoverState.Failover)) {
|
|
// Code that should run once when this script becomes the active node goes here
|
|
}
|
|
|
|
// ... your script logic goes here
|
|
}
|
|
```
|
|
|
|
Scripts that are using failover also need configuration in their Programmable Blocks' Custom Data. That should look something like this:
|
|
|
|
```
|
|
[failover]
|
|
id=scriptName # This must match for all running copies of the script.
|
|
rank=0 # The lowest ranked copy of the script will be the primary node, and they will failover in ascending rank order
|
|
``` |