Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 jkunz
|
e916ccf3ae | ||
|
jkunz
|
a435bd6fed | ||
|
jkunz
|
bf4d519428 | ||
|
jkunz
|
579667b3cd |
@@ -1,5 +1,19 @@
|
||||
# Changelog
|
||||
|
||||
## 2026-04-16 - 5.7.0 - feat(monitoring)
|
||||
add edge-triggered threshold handling with group action orchestration and HA-aware Proxmox shutdowns
|
||||
|
||||
- Track per-action threshold entry state so threshold-based actions fire only when conditions are newly violated
|
||||
- Add group monitoring and threshold evaluation for redundant and non-redundant UPS groups, including suppression of destructive actions when members are unreachable
|
||||
- Support optional Proxmox HA stop requests for HA-managed guests and prevent duplicate Proxmox or host shutdown scheduling
|
||||
|
||||
## 2026-04-14 - 5.6.0 - feat(config)
|
||||
add configurable default shutdown delay for shutdown actions
|
||||
|
||||
- introduces a top-level defaultShutdownDelay config value used by shutdown actions that do not define their own delay
|
||||
- applies the configured default during action execution, daemon-initiated shutdowns, CLI prompts, and status display output
|
||||
- preserves explicit shutdownDelay values including 0 minutes and normalizes invalid config values back to the built-in default
|
||||
|
||||
## 2026-04-14 - 5.5.1 - fix(cli,daemon,snmp)
|
||||
normalize CLI argument parsing and extract daemon monitoring helpers with stronger SNMP typing
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@serve.zone/nupst",
|
||||
"version": "5.5.1",
|
||||
"version": "5.7.0",
|
||||
"exports": "./mod.ts",
|
||||
"nodeModulesDir": "auto",
|
||||
"tasks": {
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@serve.zone/nupst",
|
||||
"version": "5.5.1",
|
||||
"version": "5.7.0",
|
||||
"description": "Network UPS Shutdown Tool - Monitor SNMP-enabled UPS devices and orchestrate graceful system shutdowns during power emergencies",
|
||||
"keywords": [
|
||||
"ups",
|
||||
|
||||
@@ -75,6 +75,8 @@
|
||||
shutdowns
|
||||
- `ts/daemon.ts` now delegates OS shutdown execution instead of embedding command lookup logic
|
||||
inline
|
||||
- `defaultShutdownDelay` in config provides the inherited delay for shutdown actions without an
|
||||
explicit `shutdownDelay` override
|
||||
|
||||
### Config Watch Handling
|
||||
|
||||
|
||||
@@ -12,12 +12,12 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
|
||||
|
||||
- **🔌 Multi-UPS Support** — Monitor multiple UPS devices from a single daemon
|
||||
- **📡 Dual Protocol Support** — SNMP (v1/v2c/v3) for network UPS + UPSD/NIS for USB-connected UPS via NUT
|
||||
- **🖥️ Proxmox Integration** — Gracefully shut down QEMU VMs and LXC containers before host shutdown (auto-detects CLI tools — no API token needed on Proxmox hosts)
|
||||
- **🖥️ Proxmox Integration** — Gracefully shut down QEMU VMs and LXC containers before host shutdown, with optional HA-aware stop requests for HA-managed guests
|
||||
- **👥 Group Management** — Organize UPS devices into groups with flexible operating modes
|
||||
- **Redundant Mode** — Only trigger actions when ALL UPS devices in a group are critical
|
||||
- **Non-Redundant Mode** — Trigger actions when ANY UPS device is critical
|
||||
- **⚙️ Action System** — Define custom responses with flexible trigger conditions
|
||||
- Battery & runtime threshold triggers
|
||||
- Edge-triggered battery & runtime threshold triggers
|
||||
- Power status change triggers
|
||||
- Webhook notifications (POST/GET)
|
||||
- Custom shell scripts
|
||||
@@ -219,12 +219,16 @@ nupst uninstall # Completely remove NUPST (requires root)
|
||||
|
||||
NUPST stores configuration at `/etc/nupst/config.json`. The easiest way to configure is through the interactive CLI commands, but you can also edit the JSON directly.
|
||||
|
||||
`defaultShutdownDelay` sets the inherited delay in minutes for shutdown actions that do not define
|
||||
their own `shutdownDelay`.
|
||||
|
||||
### Example Configuration
|
||||
|
||||
```json
|
||||
{
|
||||
"version": "4.3",
|
||||
"checkInterval": 30000,
|
||||
"defaultShutdownDelay": 5,
|
||||
"httpServer": {
|
||||
"enabled": true,
|
||||
"port": 8080,
|
||||
@@ -251,6 +255,7 @@ NUPST stores configuration at `/etc/nupst/config.json`. The easiest way to confi
|
||||
"triggerMode": "onlyThresholds",
|
||||
"thresholds": { "battery": 30, "runtime": 15 },
|
||||
"proxmoxMode": "auto",
|
||||
"proxmoxHaPolicy": "haStop",
|
||||
"proxmoxExcludeIds": [],
|
||||
"proxmoxForceStop": true
|
||||
},
|
||||
@@ -356,6 +361,10 @@ For USB-connected UPS via [NUT (Network UPS Tools)](https://networkupstools.org/
|
||||
|
||||
Actions define automated responses to UPS conditions. They run **sequentially in array order**, so place Proxmox actions before shutdown actions.
|
||||
|
||||
Threshold-based actions are **edge-triggered**: they fire when the monitored UPS or group **enters** a threshold violation, not on every polling cycle while the threshold remains violated. If the condition clears and later re-enters, the action can fire again.
|
||||
|
||||
Shutdown and Proxmox actions also suppress duplicate runs where possible, so overlapping UPS and group actions do not repeatedly schedule the same host or guest shutdown workflow.
|
||||
|
||||
#### Action Types
|
||||
|
||||
| Type | Description |
|
||||
@@ -378,8 +387,8 @@ Actions define automated responses to UPS conditions. They run **sequentially in
|
||||
| Mode | Description |
|
||||
| ----------------------------- | -------------------------------------------------------- |
|
||||
| `onlyPowerChanges` | Only when power status changes (online ↔ onBattery) |
|
||||
| `onlyThresholds` | Only when battery or runtime thresholds are violated |
|
||||
| `powerChangesAndThresholds` | On power changes OR threshold violations (default) |
|
||||
| `onlyThresholds` | Only when battery or runtime thresholds are newly violated |
|
||||
| `powerChangesAndThresholds` | On power changes OR when thresholds are newly violated (default) |
|
||||
| `anyChange` | On every polling cycle |
|
||||
|
||||
#### Shutdown Action
|
||||
@@ -395,7 +404,7 @@ Actions define automated responses to UPS conditions. They run **sequentially in
|
||||
|
||||
| Field | Description | Default |
|
||||
| --------------- | ---------------------------------- | ------- |
|
||||
| `shutdownDelay` | Minutes to wait before shutdown | `5` |
|
||||
| `shutdownDelay` | Minutes to wait before shutdown | Inherits `defaultShutdownDelay` (`5`) |
|
||||
|
||||
#### Webhook Action
|
||||
|
||||
@@ -437,6 +446,8 @@ Actions define automated responses to UPS conditions. They run **sequentially in
|
||||
|
||||
Gracefully shuts down QEMU VMs and LXC containers on a Proxmox node before the host is shut down.
|
||||
|
||||
If you use Proxmox HA, NUPST can optionally request `state=stopped` for HA-managed guests instead of only issuing direct `qm` / `pct` shutdown commands.
|
||||
|
||||
NUPST supports **two operation modes** for Proxmox:
|
||||
|
||||
| Mode | Description | Requirements |
|
||||
@@ -455,6 +466,7 @@ NUPST supports **two operation modes** for Proxmox:
|
||||
"thresholds": { "battery": 30, "runtime": 15 },
|
||||
"triggerMode": "onlyThresholds",
|
||||
"proxmoxMode": "auto",
|
||||
"proxmoxHaPolicy": "haStop",
|
||||
"proxmoxExcludeIds": [100, 101],
|
||||
"proxmoxStopTimeout": 120,
|
||||
"proxmoxForceStop": true
|
||||
@@ -469,6 +481,7 @@ NUPST supports **two operation modes** for Proxmox:
|
||||
"thresholds": { "battery": 30, "runtime": 15 },
|
||||
"triggerMode": "onlyThresholds",
|
||||
"proxmoxMode": "api",
|
||||
"proxmoxHaPolicy": "haStop",
|
||||
"proxmoxHost": "localhost",
|
||||
"proxmoxPort": 8006,
|
||||
"proxmoxTokenId": "root@pam!nupst",
|
||||
@@ -483,6 +496,7 @@ NUPST supports **two operation modes** for Proxmox:
|
||||
| Field | Description | Default |
|
||||
| --------------------- | ----------------------------------------------- | ------------- |
|
||||
| `proxmoxMode` | Operation mode | `auto` |
|
||||
| `proxmoxHaPolicy` | HA handling for HA-managed guests | `none`, `haStop` (`none` default) |
|
||||
| `proxmoxHost` | Proxmox API host (API mode only) | `localhost` |
|
||||
| `proxmoxPort` | Proxmox API port (API mode only) | `8006` |
|
||||
| `proxmoxNode` | Proxmox node name | Auto-detect via hostname |
|
||||
@@ -500,11 +514,20 @@ NUPST supports **two operation modes** for Proxmox:
|
||||
pveum user token add root@pam nupst --privsep=0
|
||||
```
|
||||
|
||||
**HA Policy values:**
|
||||
|
||||
- **`none`** — Treat HA-managed and non-HA guests the same. NUPST sends normal guest shutdown commands.
|
||||
- **`haStop`** — For HA-managed guests, NUPST requests HA resource state `stopped`. Non-HA guests still use normal shutdown commands.
|
||||
|
||||
> ⚠️ **Important:** Place the Proxmox action **before** the shutdown action in the actions array so VMs are stopped before the host shuts down.
|
||||
|
||||
### Group Configuration
|
||||
|
||||
Groups coordinate actions across multiple UPS devices:
|
||||
Groups coordinate actions across multiple UPS devices.
|
||||
|
||||
Group actions are evaluated **after all UPS devices have been refreshed for a polling cycle**.
|
||||
|
||||
There is **no aggregate battery math** across the group. Instead, each group action evaluates each member UPS against that action's own thresholds.
|
||||
|
||||
| Field | Description | Values |
|
||||
| ------------- | ---------------------------------- | -------------------- |
|
||||
@@ -516,8 +539,10 @@ Groups coordinate actions across multiple UPS devices:
|
||||
|
||||
**Group Modes:**
|
||||
|
||||
- **`redundant`** — Actions trigger only when ALL UPS devices in the group are critical. Use for setups with backup power units.
|
||||
- **`nonRedundant`** — Actions trigger when ANY UPS device is critical. Use when all UPS units must be operational.
|
||||
- **`redundant`** — A threshold-based action triggers only when **all** UPS devices in the group are on battery and below that action's thresholds. Use for setups with backup power units.
|
||||
- **`nonRedundant`** — A threshold-based action triggers when **any** UPS device in the group is on battery and below that action's thresholds. Use when all UPS units must be operational.
|
||||
|
||||
For threshold-based **destructive** group actions (`shutdown` and `proxmox`), NUPST suppresses execution while any group member is `unreachable`. This prevents acting on partial data during network failures.
|
||||
|
||||
### HTTP Server Configuration
|
||||
|
||||
@@ -593,6 +618,7 @@ NUPST tracks communication failures per UPS device:
|
||||
- After **3 consecutive failures**, the UPS status transitions to `unreachable`
|
||||
- **Shutdown actions will NOT fire** on `unreachable` — this prevents false shutdowns from network glitches
|
||||
- Webhook and script actions still fire, allowing you to send alerts
|
||||
- Threshold-based destructive **group** actions are also suppressed while any required group member is `unreachable`
|
||||
- When connectivity is restored, NUPST logs a recovery event with downtime duration
|
||||
- The failure counter is capped at 100 to prevent overflow
|
||||
|
||||
@@ -609,17 +635,17 @@ UPS Devices (2):
|
||||
✓ Main Server UPS (online - 100%, 3840min)
|
||||
Host: 192.168.1.100:161 (SNMP)
|
||||
Groups: Data Center
|
||||
Action: proxmox (onlyThresholds: battery<30%, runtime<15min)
|
||||
Action: shutdown (onlyThresholds: battery<20%, runtime<10min, delay=10s)
|
||||
Action: proxmox (onlyThresholds: battery<30%, runtime<15min, ha=stop)
|
||||
Action: shutdown (onlyThresholds: battery<20%, runtime<10min, delay=10min)
|
||||
|
||||
✓ Local USB UPS (online - 95%, 2400min)
|
||||
Host: 127.0.0.1:3493 (UPSD)
|
||||
Action: shutdown (onlyThresholds: battery<15%, runtime<5min, delay=5s)
|
||||
Action: shutdown (onlyThresholds: battery<15%, runtime<5min, delay=5min)
|
||||
|
||||
Groups (1):
|
||||
ℹ Data Center (redundant)
|
||||
UPS Devices (1): Main Server UPS
|
||||
Action: shutdown (onlyThresholds: battery<10%, runtime<5min, delay=15s)
|
||||
Action: shutdown (onlyThresholds: battery<10%, runtime<5min, delay=15min)
|
||||
```
|
||||
|
||||
### Live Logs
|
||||
@@ -780,6 +806,9 @@ curl -k -H "Authorization: PVEAPIToken=root@pam!nupst=YOUR-SECRET" \
|
||||
|
||||
# Check token permissions
|
||||
pveum user token list root@pam
|
||||
|
||||
# If using proxmoxHaPolicy: haStop
|
||||
ha-manager config
|
||||
```
|
||||
|
||||
### Actions Not Triggering
|
||||
|
||||
+232
-1
@@ -11,7 +11,11 @@ import { type IPauseState, loadPauseSnapshot } from '../ts/pause-state.ts';
|
||||
import { shortId } from '../ts/helpers/shortid.ts';
|
||||
import { HTTP_SERVER, SNMP, THRESHOLDS, TIMING, UI } from '../ts/constants.ts';
|
||||
import { Action, type IActionContext } from '../ts/actions/base-action.ts';
|
||||
import { buildUpsActionContext, decideUpsActionExecution } from '../ts/action-orchestration.ts';
|
||||
import {
|
||||
applyDefaultShutdownDelay,
|
||||
buildUpsActionContext,
|
||||
decideUpsActionExecution,
|
||||
} from '../ts/action-orchestration.ts';
|
||||
import {
|
||||
buildShutdownErrorRow,
|
||||
buildShutdownStatusRow,
|
||||
@@ -20,8 +24,16 @@ import {
|
||||
import {
|
||||
buildFailedUpsPollSnapshot,
|
||||
buildSuccessfulUpsPollSnapshot,
|
||||
getActionThresholdStates,
|
||||
getEnteredThresholdIndexes,
|
||||
hasThresholdViolation,
|
||||
isActionThresholdExceeded,
|
||||
} from '../ts/ups-monitoring.ts';
|
||||
import {
|
||||
buildGroupStatusSnapshot,
|
||||
buildGroupThresholdContextStatus,
|
||||
evaluateGroupActionThreshold,
|
||||
} from '../ts/group-monitoring.ts';
|
||||
import { createInitialUpsStatus } from '../ts/ups-status.ts';
|
||||
|
||||
import * as qenv from 'npm:@push.rocks/qenv@^6.0.0';
|
||||
@@ -353,6 +365,22 @@ Deno.test('decideUpsActionExecution: returns executable action plan when actions
|
||||
});
|
||||
});
|
||||
|
||||
Deno.test('applyDefaultShutdownDelay: applies only to shutdown actions without explicit delay', () => {
|
||||
const actions = [
|
||||
{ type: 'shutdown' as const },
|
||||
{ type: 'shutdown' as const, shutdownDelay: 0 },
|
||||
{ type: 'shutdown' as const, shutdownDelay: 9 },
|
||||
{ type: 'webhook' as const },
|
||||
];
|
||||
|
||||
assertEquals(applyDefaultShutdownDelay(actions, 7), [
|
||||
{ type: 'shutdown', shutdownDelay: 7 },
|
||||
{ type: 'shutdown', shutdownDelay: 0 },
|
||||
{ type: 'shutdown', shutdownDelay: 9 },
|
||||
{ type: 'webhook' },
|
||||
]);
|
||||
});
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Shutdown Monitoring Tests
|
||||
// -----------------------------------------------------------------------------
|
||||
@@ -512,6 +540,209 @@ Deno.test('hasThresholdViolation: only fires on battery when any action threshol
|
||||
);
|
||||
});
|
||||
|
||||
Deno.test('isActionThresholdExceeded: evaluates a single action threshold on battery only', () => {
|
||||
assertEquals(
|
||||
isActionThresholdExceeded(
|
||||
{ type: 'shutdown', thresholds: { battery: 50, runtime: 20 } },
|
||||
'online',
|
||||
40,
|
||||
10,
|
||||
),
|
||||
false,
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
isActionThresholdExceeded(
|
||||
{ type: 'shutdown', thresholds: { battery: 50, runtime: 20 } },
|
||||
'onBattery',
|
||||
40,
|
||||
10,
|
||||
),
|
||||
true,
|
||||
);
|
||||
});
|
||||
|
||||
Deno.test('getActionThresholdStates: returns per-action threshold state array', () => {
|
||||
assertEquals(
|
||||
getActionThresholdStates('onBattery', 25, 8, [
|
||||
{ type: 'shutdown', thresholds: { battery: 30, runtime: 10 } },
|
||||
{ type: 'shutdown', thresholds: { battery: 10, runtime: 5 } },
|
||||
{ type: 'webhook' },
|
||||
]),
|
||||
[true, false, false],
|
||||
);
|
||||
});
|
||||
|
||||
Deno.test('getEnteredThresholdIndexes: reports only newly-entered thresholds', () => {
|
||||
assertEquals(getEnteredThresholdIndexes(undefined, [false, true, true]), [1, 2]);
|
||||
assertEquals(getEnteredThresholdIndexes([false, true, false], [true, true, false]), [0]);
|
||||
assertEquals(getEnteredThresholdIndexes([true, true], [true, false]), []);
|
||||
});
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Group Monitoring Tests
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
Deno.test('buildGroupStatusSnapshot: redundant group stays online while one UPS remains online', () => {
|
||||
const snapshot = buildGroupStatusSnapshot(
|
||||
{ id: 'group-1', name: 'Group Main' },
|
||||
'redundant',
|
||||
[
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 40,
|
||||
batteryRuntime: 12,
|
||||
},
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
batteryCapacity: 98,
|
||||
batteryRuntime: 999,
|
||||
},
|
||||
],
|
||||
undefined,
|
||||
5000,
|
||||
);
|
||||
|
||||
assertEquals(snapshot.updatedStatus.powerStatus, 'online');
|
||||
assertEquals(snapshot.transition, 'powerStatusChange');
|
||||
});
|
||||
|
||||
Deno.test('buildGroupStatusSnapshot: nonRedundant group goes unreachable when any member is unreachable', () => {
|
||||
const snapshot = buildGroupStatusSnapshot(
|
||||
{ id: 'group-2', name: 'Group Edge' },
|
||||
'nonRedundant',
|
||||
[
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
},
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'unreachable' as const,
|
||||
unreachableSince: 2000,
|
||||
},
|
||||
],
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'group-2', name: 'Group Edge' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
},
|
||||
6000,
|
||||
);
|
||||
|
||||
assertEquals(snapshot.updatedStatus.powerStatus, 'unreachable');
|
||||
assertEquals(snapshot.transition, 'powerStatusChange');
|
||||
});
|
||||
|
||||
Deno.test('evaluateGroupActionThreshold: redundant mode requires all members to be critical', () => {
|
||||
const evaluation = evaluateGroupActionThreshold(
|
||||
{ type: 'shutdown', thresholds: { battery: 50, runtime: 20 } },
|
||||
'redundant',
|
||||
[
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 40,
|
||||
batteryRuntime: 15,
|
||||
},
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
batteryCapacity: 95,
|
||||
batteryRuntime: 999,
|
||||
},
|
||||
],
|
||||
);
|
||||
|
||||
assertEquals(evaluation.exceedsThreshold, false);
|
||||
});
|
||||
|
||||
Deno.test('evaluateGroupActionThreshold: nonRedundant mode trips on any critical member', () => {
|
||||
const evaluation = evaluateGroupActionThreshold(
|
||||
{ type: 'shutdown', thresholds: { battery: 50, runtime: 20 } },
|
||||
'nonRedundant',
|
||||
[
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 40,
|
||||
batteryRuntime: 15,
|
||||
},
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
batteryCapacity: 95,
|
||||
batteryRuntime: 999,
|
||||
},
|
||||
],
|
||||
);
|
||||
|
||||
assertEquals(evaluation.exceedsThreshold, true);
|
||||
assertEquals(evaluation.blockedByUnreachable, false);
|
||||
});
|
||||
|
||||
Deno.test('evaluateGroupActionThreshold: blocks destructive actions when a member is unreachable', () => {
|
||||
const evaluation = evaluateGroupActionThreshold(
|
||||
{ type: 'proxmox', thresholds: { battery: 50, runtime: 20 } },
|
||||
'nonRedundant',
|
||||
[
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 25,
|
||||
batteryRuntime: 8,
|
||||
},
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'unreachable' as const,
|
||||
unreachableSince: 3000,
|
||||
},
|
||||
],
|
||||
);
|
||||
|
||||
assertEquals(evaluation.exceedsThreshold, true);
|
||||
assertEquals(evaluation.blockedByUnreachable, true);
|
||||
});
|
||||
|
||||
Deno.test('buildGroupThresholdContextStatus: uses the worst triggering member runtime', () => {
|
||||
const status = buildGroupThresholdContextStatus(
|
||||
{ id: 'group-3', name: 'Group Worst' },
|
||||
[
|
||||
{
|
||||
exceedsThreshold: true,
|
||||
blockedByUnreachable: false,
|
||||
representativeStatus: {
|
||||
...createInitialUpsStatus({ id: 'ups-1', name: 'UPS 1' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 30,
|
||||
batteryRuntime: 9,
|
||||
},
|
||||
},
|
||||
{
|
||||
exceedsThreshold: true,
|
||||
blockedByUnreachable: false,
|
||||
representativeStatus: {
|
||||
...createInitialUpsStatus({ id: 'ups-2', name: 'UPS 2' }, 1000),
|
||||
powerStatus: 'onBattery' as const,
|
||||
batteryCapacity: 20,
|
||||
batteryRuntime: 4,
|
||||
},
|
||||
},
|
||||
],
|
||||
[0, 1],
|
||||
{
|
||||
...createInitialUpsStatus({ id: 'group-3', name: 'Group Worst' }, 1000),
|
||||
powerStatus: 'online' as const,
|
||||
},
|
||||
7000,
|
||||
);
|
||||
|
||||
assertEquals(status.powerStatus, 'onBattery');
|
||||
assertEquals(status.batteryCapacity, 20);
|
||||
assertEquals(status.batteryRuntime, 4);
|
||||
});
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// UpsOidSets Tests
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
@@ -3,6 +3,6 @@
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@serve.zone/nupst',
|
||||
version: '5.5.1',
|
||||
version: '5.7.0',
|
||||
description: 'Network UPS Shutdown Tool - Monitor SNMP-enabled UPS devices and orchestrate graceful system shutdowns during power emergencies'
|
||||
}
|
||||
|
||||
@@ -34,6 +34,22 @@ export function buildUpsActionContext(
|
||||
};
|
||||
}
|
||||
|
||||
export function applyDefaultShutdownDelay(
|
||||
actions: IActionConfig[],
|
||||
defaultDelayMinutes: number,
|
||||
): IActionConfig[] {
|
||||
return actions.map((action) => {
|
||||
if (action.type !== 'shutdown' || action.shutdownDelay !== undefined) {
|
||||
return action;
|
||||
}
|
||||
|
||||
return {
|
||||
...action,
|
||||
shutdownDelay: defaultDelayMinutes,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export function decideUpsActionExecution(
|
||||
isPaused: boolean,
|
||||
ups: IUpsActionSource,
|
||||
|
||||
@@ -74,7 +74,7 @@ export interface IActionConfig {
|
||||
};
|
||||
|
||||
// Shutdown action configuration
|
||||
/** Delay before shutdown in minutes (default: 5) */
|
||||
/** Delay before shutdown in minutes (defaults to the config-level shutdown delay, or 5) */
|
||||
shutdownDelay?: number;
|
||||
/** Only execute shutdown on threshold violation, not power status changes */
|
||||
onlyOnThresholdViolation?: boolean;
|
||||
@@ -118,6 +118,8 @@ export interface IActionConfig {
|
||||
proxmoxInsecure?: boolean;
|
||||
/** Proxmox operation mode: 'auto' detects CLI tools, 'cli' forces CLI, 'api' forces REST API (default: 'auto') */
|
||||
proxmoxMode?: 'auto' | 'api' | 'cli';
|
||||
/** How HA-managed Proxmox resources should be stopped (default: 'none') */
|
||||
proxmoxHaPolicy?: 'none' | 'haStop';
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+298
-66
@@ -8,6 +8,11 @@ import { logger } from '../logger.ts';
|
||||
import { PROXMOX, UI } from '../constants.ts';
|
||||
|
||||
const execFileAsync = promisify(execFile);
|
||||
type TNodeLikeGlobal = typeof globalThis & {
|
||||
process?: {
|
||||
env: Record<string, string | undefined>;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* ProxmoxAction - Gracefully shuts down Proxmox VMs and LXC containers
|
||||
@@ -23,6 +28,22 @@ const execFileAsync = promisify(execFile);
|
||||
*/
|
||||
export class ProxmoxAction extends Action {
|
||||
readonly type = 'proxmox';
|
||||
private static readonly activeRunKeys = new Set<string>();
|
||||
|
||||
private static findCliTool(command: string): string | null {
|
||||
for (const dir of PROXMOX.CLI_TOOL_PATHS) {
|
||||
const candidate = `${dir}/${command}`;
|
||||
try {
|
||||
if (fs.existsSync(candidate)) {
|
||||
return candidate;
|
||||
}
|
||||
} catch (_e) {
|
||||
// continue
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if Proxmox CLI tools (qm, pct) are available on the system
|
||||
@@ -32,29 +53,12 @@ export class ProxmoxAction extends Action {
|
||||
available: boolean;
|
||||
qmPath: string | null;
|
||||
pctPath: string | null;
|
||||
haManagerPath: string | null;
|
||||
isRoot: boolean;
|
||||
} {
|
||||
let qmPath: string | null = null;
|
||||
let pctPath: string | null = null;
|
||||
|
||||
for (const dir of PROXMOX.CLI_TOOL_PATHS) {
|
||||
if (!qmPath) {
|
||||
const p = `${dir}/qm`;
|
||||
try {
|
||||
if (fs.existsSync(p)) qmPath = p;
|
||||
} catch (_e) {
|
||||
// continue
|
||||
}
|
||||
}
|
||||
if (!pctPath) {
|
||||
const p = `${dir}/pct`;
|
||||
try {
|
||||
if (fs.existsSync(p)) pctPath = p;
|
||||
} catch (_e) {
|
||||
// continue
|
||||
}
|
||||
}
|
||||
}
|
||||
const qmPath = this.findCliTool('qm');
|
||||
const pctPath = this.findCliTool('pct');
|
||||
const haManagerPath = this.findCliTool('ha-manager');
|
||||
|
||||
const isRoot = !!(process.getuid && process.getuid() === 0);
|
||||
|
||||
@@ -62,6 +66,7 @@ export class ProxmoxAction extends Action {
|
||||
available: qmPath !== null && pctPath !== null && isRoot,
|
||||
qmPath,
|
||||
pctPath,
|
||||
haManagerPath,
|
||||
isRoot,
|
||||
};
|
||||
}
|
||||
@@ -69,7 +74,11 @@ export class ProxmoxAction extends Action {
|
||||
/**
|
||||
* Resolve the operation mode based on config and environment
|
||||
*/
|
||||
private resolveMode(): { mode: 'api' | 'cli'; qmPath: string; pctPath: string } | { mode: 'api'; qmPath?: undefined; pctPath?: undefined } {
|
||||
private resolveMode(): { mode: 'api' | 'cli'; qmPath: string; pctPath: string } | {
|
||||
mode: 'api';
|
||||
qmPath?: undefined;
|
||||
pctPath?: undefined;
|
||||
} {
|
||||
const configuredMode = this.config.proxmoxMode || 'auto';
|
||||
|
||||
if (configuredMode === 'api') {
|
||||
@@ -111,16 +120,29 @@ export class ProxmoxAction extends Action {
|
||||
const resolved = this.resolveMode();
|
||||
const node = this.config.proxmoxNode || os.hostname();
|
||||
const excludeIds = new Set(this.config.proxmoxExcludeIds || []);
|
||||
const stopTimeout = (this.config.proxmoxStopTimeout || PROXMOX.DEFAULT_STOP_TIMEOUT_SECONDS) * 1000;
|
||||
const stopTimeout = (this.config.proxmoxStopTimeout || PROXMOX.DEFAULT_STOP_TIMEOUT_SECONDS) *
|
||||
1000;
|
||||
const forceStop = this.config.proxmoxForceStop !== false; // default true
|
||||
const haPolicy = this.config.proxmoxHaPolicy || 'none';
|
||||
const host = this.config.proxmoxHost || PROXMOX.DEFAULT_HOST;
|
||||
const port = this.config.proxmoxPort || PROXMOX.DEFAULT_PORT;
|
||||
const runKey = `${resolved.mode}:${node}:${
|
||||
resolved.mode === 'api' ? `${host}:${port}` : 'local'
|
||||
}`;
|
||||
|
||||
if (ProxmoxAction.activeRunKeys.has(runKey)) {
|
||||
logger.info(`Proxmox action skipped: shutdown sequence already running for node ${node}`);
|
||||
return;
|
||||
}
|
||||
|
||||
ProxmoxAction.activeRunKeys.add(runKey);
|
||||
|
||||
logger.log('');
|
||||
logger.logBoxTitle('Proxmox VM Shutdown', UI.WIDE_BOX_WIDTH, 'warning');
|
||||
logger.logBoxLine(`Mode: ${resolved.mode === 'cli' ? 'CLI (qm/pct)' : 'API (REST)'}`);
|
||||
logger.logBoxLine(`Node: ${node}`);
|
||||
logger.logBoxLine(`HA Policy: ${haPolicy}`);
|
||||
if (resolved.mode === 'api') {
|
||||
const host = this.config.proxmoxHost || PROXMOX.DEFAULT_HOST;
|
||||
const port = this.config.proxmoxPort || PROXMOX.DEFAULT_PORT;
|
||||
logger.logBoxLine(`API: ${host}:${port}`);
|
||||
}
|
||||
logger.logBoxLine(`UPS: ${context.upsName} (${context.powerStatus})`);
|
||||
@@ -132,6 +154,11 @@ export class ProxmoxAction extends Action {
|
||||
logger.log('');
|
||||
|
||||
try {
|
||||
let apiContext: {
|
||||
baseUrl: string;
|
||||
headers: Record<string, string>;
|
||||
insecure: boolean;
|
||||
} | null = null;
|
||||
let runningVMs: Array<{ vmid: number; name: string }>;
|
||||
let runningCTs: Array<{ vmid: number; name: string }>;
|
||||
|
||||
@@ -140,8 +167,6 @@ export class ProxmoxAction extends Action {
|
||||
runningCTs = await this.getRunningCTsCli(resolved.pctPath);
|
||||
} else {
|
||||
// API mode - validate token
|
||||
const host = this.config.proxmoxHost || PROXMOX.DEFAULT_HOST;
|
||||
const port = this.config.proxmoxPort || PROXMOX.DEFAULT_PORT;
|
||||
const tokenId = this.config.proxmoxTokenId;
|
||||
const tokenSecret = this.config.proxmoxTokenSecret;
|
||||
const insecure = this.config.proxmoxInsecure !== false;
|
||||
@@ -152,13 +177,26 @@ export class ProxmoxAction extends Action {
|
||||
return;
|
||||
}
|
||||
|
||||
const baseUrl = `https://${host}:${port}${PROXMOX.API_BASE}`;
|
||||
const headers: Record<string, string> = {
|
||||
'Authorization': `PVEAPIToken=${tokenId}=${tokenSecret}`,
|
||||
apiContext = {
|
||||
baseUrl: `https://${host}:${port}${PROXMOX.API_BASE}`,
|
||||
headers: {
|
||||
'Authorization': `PVEAPIToken=${tokenId}=${tokenSecret}`,
|
||||
},
|
||||
insecure,
|
||||
};
|
||||
|
||||
runningVMs = await this.getRunningVMsApi(baseUrl, node, headers, insecure);
|
||||
runningCTs = await this.getRunningCTsApi(baseUrl, node, headers, insecure);
|
||||
runningVMs = await this.getRunningVMsApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
runningCTs = await this.getRunningCTsApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
}
|
||||
|
||||
// Filter out excluded IDs
|
||||
@@ -171,33 +209,83 @@ export class ProxmoxAction extends Action {
|
||||
return;
|
||||
}
|
||||
|
||||
const haManagedResources = haPolicy === 'haStop'
|
||||
? await this.getHaManagedResources(resolved, apiContext)
|
||||
: { qemu: new Set<number>(), lxc: new Set<number>() };
|
||||
const haVmsToStop = vmsToStop.filter((vm) => haManagedResources.qemu.has(vm.vmid));
|
||||
const haCtsToStop = ctsToStop.filter((ct) => haManagedResources.lxc.has(ct.vmid));
|
||||
let directVmsToStop = vmsToStop.filter((vm) => !haManagedResources.qemu.has(vm.vmid));
|
||||
let directCtsToStop = ctsToStop.filter((ct) => !haManagedResources.lxc.has(ct.vmid));
|
||||
|
||||
logger.info(`Shutting down ${vmsToStop.length} VMs and ${ctsToStop.length} containers...`);
|
||||
|
||||
// Send shutdown commands
|
||||
if (resolved.mode === 'cli') {
|
||||
for (const vm of vmsToStop) {
|
||||
const { haManagerPath } = ProxmoxAction.detectCliAvailability();
|
||||
if (haPolicy === 'haStop' && (haVmsToStop.length > 0 || haCtsToStop.length > 0)) {
|
||||
if (!haManagerPath) {
|
||||
logger.warn(
|
||||
'ha-manager not found, falling back to direct guest shutdown for HA-managed resources',
|
||||
);
|
||||
directVmsToStop = [...haVmsToStop, ...directVmsToStop];
|
||||
directCtsToStop = [...haCtsToStop, ...directCtsToStop];
|
||||
} else {
|
||||
for (const vm of haVmsToStop) {
|
||||
await this.requestHaStopCli(haManagerPath, `vm:${vm.vmid}`);
|
||||
logger.dim(` HA stop requested for VM ${vm.vmid} (${vm.name || 'unnamed'})`);
|
||||
}
|
||||
for (const ct of haCtsToStop) {
|
||||
await this.requestHaStopCli(haManagerPath, `ct:${ct.vmid}`);
|
||||
logger.dim(` HA stop requested for CT ${ct.vmid} (${ct.name || 'unnamed'})`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const vm of directVmsToStop) {
|
||||
await this.shutdownVMCli(resolved.qmPath, vm.vmid);
|
||||
logger.dim(` Shutdown sent to VM ${vm.vmid} (${vm.name || 'unnamed'})`);
|
||||
}
|
||||
for (const ct of ctsToStop) {
|
||||
for (const ct of directCtsToStop) {
|
||||
await this.shutdownCTCli(resolved.pctPath, ct.vmid);
|
||||
logger.dim(` Shutdown sent to CT ${ct.vmid} (${ct.name || 'unnamed'})`);
|
||||
}
|
||||
} else {
|
||||
const host = this.config.proxmoxHost || PROXMOX.DEFAULT_HOST;
|
||||
const port = this.config.proxmoxPort || PROXMOX.DEFAULT_PORT;
|
||||
const insecure = this.config.proxmoxInsecure !== false;
|
||||
const baseUrl = `https://${host}:${port}${PROXMOX.API_BASE}`;
|
||||
const headers: Record<string, string> = {
|
||||
'Authorization': `PVEAPIToken=${this.config.proxmoxTokenId}=${this.config.proxmoxTokenSecret}`,
|
||||
};
|
||||
} else if (apiContext) {
|
||||
for (const vm of haVmsToStop) {
|
||||
await this.requestHaStopApi(
|
||||
apiContext.baseUrl,
|
||||
`vm:${vm.vmid}`,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
logger.dim(` HA stop requested for VM ${vm.vmid} (${vm.name || 'unnamed'})`);
|
||||
}
|
||||
for (const ct of haCtsToStop) {
|
||||
await this.requestHaStopApi(
|
||||
apiContext.baseUrl,
|
||||
`ct:${ct.vmid}`,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
logger.dim(` HA stop requested for CT ${ct.vmid} (${ct.name || 'unnamed'})`);
|
||||
}
|
||||
|
||||
for (const vm of vmsToStop) {
|
||||
await this.shutdownVMApi(baseUrl, node, vm.vmid, headers, insecure);
|
||||
for (const vm of directVmsToStop) {
|
||||
await this.shutdownVMApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
vm.vmid,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
logger.dim(` Shutdown sent to VM ${vm.vmid} (${vm.name || 'unnamed'})`);
|
||||
}
|
||||
for (const ct of ctsToStop) {
|
||||
await this.shutdownCTApi(baseUrl, node, ct.vmid, headers, insecure);
|
||||
for (const ct of directCtsToStop) {
|
||||
await this.shutdownCTApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
ct.vmid,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
logger.dim(` Shutdown sent to CT ${ct.vmid} (${ct.name || 'unnamed'})`);
|
||||
}
|
||||
}
|
||||
@@ -220,18 +308,23 @@ export class ProxmoxAction extends Action {
|
||||
} else {
|
||||
await this.stopCTCli(resolved.pctPath, item.vmid);
|
||||
}
|
||||
} else {
|
||||
const host = this.config.proxmoxHost || PROXMOX.DEFAULT_HOST;
|
||||
const port = this.config.proxmoxPort || PROXMOX.DEFAULT_PORT;
|
||||
const insecure = this.config.proxmoxInsecure !== false;
|
||||
const baseUrl = `https://${host}:${port}${PROXMOX.API_BASE}`;
|
||||
const headers: Record<string, string> = {
|
||||
'Authorization': `PVEAPIToken=${this.config.proxmoxTokenId}=${this.config.proxmoxTokenSecret}`,
|
||||
};
|
||||
} else if (apiContext) {
|
||||
if (item.type === 'qemu') {
|
||||
await this.stopVMApi(baseUrl, node, item.vmid, headers, insecure);
|
||||
await this.stopVMApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
item.vmid,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
} else {
|
||||
await this.stopCTApi(baseUrl, node, item.vmid, headers, insecure);
|
||||
await this.stopCTApi(
|
||||
apiContext.baseUrl,
|
||||
node,
|
||||
item.vmid,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
}
|
||||
}
|
||||
logger.dim(` Force-stopped ${item.type} ${item.vmid} (${item.name || 'unnamed'})`);
|
||||
@@ -252,6 +345,8 @@ export class ProxmoxAction extends Action {
|
||||
logger.error(
|
||||
`Proxmox action failed: ${error instanceof Error ? error.message : String(error)}`,
|
||||
);
|
||||
} finally {
|
||||
ProxmoxAction.activeRunKeys.delete(runKey);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -357,6 +452,77 @@ export class ProxmoxAction extends Action {
|
||||
return status;
|
||||
}
|
||||
|
||||
private async getHaManagedResources(
|
||||
resolved: { mode: 'api' | 'cli'; qmPath?: string; pctPath?: string },
|
||||
apiContext: {
|
||||
baseUrl: string;
|
||||
headers: Record<string, string>;
|
||||
insecure: boolean;
|
||||
} | null,
|
||||
): Promise<{ qemu: Set<number>; lxc: Set<number> }> {
|
||||
if (resolved.mode === 'cli') {
|
||||
const { haManagerPath } = ProxmoxAction.detectCliAvailability();
|
||||
if (!haManagerPath) {
|
||||
return { qemu: new Set<number>(), lxc: new Set<number>() };
|
||||
}
|
||||
|
||||
return await this.getHaManagedResourcesCli(haManagerPath);
|
||||
}
|
||||
|
||||
if (!apiContext) {
|
||||
return { qemu: new Set<number>(), lxc: new Set<number>() };
|
||||
}
|
||||
|
||||
return await this.getHaManagedResourcesApi(
|
||||
apiContext.baseUrl,
|
||||
apiContext.headers,
|
||||
apiContext.insecure,
|
||||
);
|
||||
}
|
||||
|
||||
private async getHaManagedResourcesCli(
|
||||
haManagerPath: string,
|
||||
): Promise<{ qemu: Set<number>; lxc: Set<number> }> {
|
||||
try {
|
||||
const { stdout } = await execFileAsync(haManagerPath, ['config']);
|
||||
return this.parseHaManagerConfig(stdout);
|
||||
} catch (error) {
|
||||
logger.warn(
|
||||
`Failed to list HA resources via CLI: ${
|
||||
error instanceof Error ? error.message : String(error)
|
||||
}`,
|
||||
);
|
||||
return { qemu: new Set<number>(), lxc: new Set<number>() };
|
||||
}
|
||||
}
|
||||
|
||||
private parseHaManagerConfig(output: string): { qemu: Set<number>; lxc: Set<number> } {
|
||||
const resources = {
|
||||
qemu: new Set<number>(),
|
||||
lxc: new Set<number>(),
|
||||
};
|
||||
|
||||
for (const line of output.trim().split('\n')) {
|
||||
const match = line.match(/^\s*(vm|ct)\s*:\s*(\d+)\s*$/i);
|
||||
if (!match) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const vmid = parseInt(match[2], 10);
|
||||
if (match[1].toLowerCase() === 'vm') {
|
||||
resources.qemu.add(vmid);
|
||||
} else {
|
||||
resources.lxc.add(vmid);
|
||||
}
|
||||
}
|
||||
|
||||
return resources;
|
||||
}
|
||||
|
||||
private async requestHaStopCli(haManagerPath: string, sid: string): Promise<void> {
|
||||
await execFileAsync(haManagerPath, ['set', sid, '--state', 'stopped']);
|
||||
}
|
||||
|
||||
// ─── API-based methods ─────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
@@ -367,16 +533,23 @@ export class ProxmoxAction extends Action {
|
||||
method: string,
|
||||
headers: Record<string, string>,
|
||||
insecure: boolean,
|
||||
body?: URLSearchParams,
|
||||
): Promise<unknown> {
|
||||
const requestHeaders = { ...headers };
|
||||
const fetchOptions: RequestInit = {
|
||||
method,
|
||||
headers,
|
||||
headers: requestHeaders,
|
||||
};
|
||||
|
||||
if (body) {
|
||||
requestHeaders['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
|
||||
fetchOptions.body = body.toString();
|
||||
}
|
||||
|
||||
// Use NODE_TLS_REJECT_UNAUTHORIZED for insecure mode (self-signed certs)
|
||||
if (insecure) {
|
||||
// deno-lint-ignore no-explicit-any
|
||||
(globalThis as any).process?.env && ((globalThis as any).process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0');
|
||||
const nodeProcess = (globalThis as TNodeLikeGlobal).process;
|
||||
if (insecure && nodeProcess?.env) {
|
||||
nodeProcess.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
|
||||
}
|
||||
|
||||
try {
|
||||
@@ -390,9 +563,8 @@ export class ProxmoxAction extends Action {
|
||||
return await response.json();
|
||||
} finally {
|
||||
// Restore TLS verification
|
||||
if (insecure) {
|
||||
// deno-lint-ignore no-explicit-any
|
||||
(globalThis as any).process?.env && ((globalThis as any).process.env.NODE_TLS_REJECT_UNAUTHORIZED = '1');
|
||||
if (insecure && nodeProcess?.env) {
|
||||
nodeProcess.env.NODE_TLS_REJECT_UNAUTHORIZED = '1';
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -453,6 +625,63 @@ export class ProxmoxAction extends Action {
|
||||
}
|
||||
}
|
||||
|
||||
private async getHaManagedResourcesApi(
|
||||
baseUrl: string,
|
||||
headers: Record<string, string>,
|
||||
insecure: boolean,
|
||||
): Promise<{ qemu: Set<number>; lxc: Set<number> }> {
|
||||
try {
|
||||
const response = await this.apiRequest(
|
||||
`${baseUrl}/cluster/ha/resources`,
|
||||
'GET',
|
||||
headers,
|
||||
insecure,
|
||||
) as { data: Array<{ sid?: string }> };
|
||||
const resources = {
|
||||
qemu: new Set<number>(),
|
||||
lxc: new Set<number>(),
|
||||
};
|
||||
|
||||
for (const item of response.data || []) {
|
||||
const match = item.sid?.match(/^(vm|ct):(\d+)$/i);
|
||||
if (!match) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const vmid = parseInt(match[2], 10);
|
||||
if (match[1].toLowerCase() === 'vm') {
|
||||
resources.qemu.add(vmid);
|
||||
} else {
|
||||
resources.lxc.add(vmid);
|
||||
}
|
||||
}
|
||||
|
||||
return resources;
|
||||
} catch (error) {
|
||||
logger.warn(
|
||||
`Failed to list HA resources via API: ${
|
||||
error instanceof Error ? error.message : String(error)
|
||||
}`,
|
||||
);
|
||||
return { qemu: new Set<number>(), lxc: new Set<number>() };
|
||||
}
|
||||
}
|
||||
|
||||
private async requestHaStopApi(
|
||||
baseUrl: string,
|
||||
sid: string,
|
||||
headers: Record<string, string>,
|
||||
insecure: boolean,
|
||||
): Promise<void> {
|
||||
await this.apiRequest(
|
||||
`${baseUrl}/cluster/ha/resources/${encodeURIComponent(sid)}`,
|
||||
'PUT',
|
||||
headers,
|
||||
insecure,
|
||||
new URLSearchParams({ state: 'stopped' }),
|
||||
);
|
||||
}
|
||||
|
||||
private async shutdownVMApi(
|
||||
baseUrl: string,
|
||||
node: string,
|
||||
@@ -529,7 +758,9 @@ export class ProxmoxAction extends Action {
|
||||
|
||||
while (remaining.length > 0 && (Date.now() - startTime) < timeout) {
|
||||
// Wait before polling
|
||||
await new Promise((resolve) => setTimeout(resolve, PROXMOX.STATUS_POLL_INTERVAL_SECONDS * 1000));
|
||||
await new Promise((resolve) =>
|
||||
setTimeout(resolve, PROXMOX.STATUS_POLL_INTERVAL_SECONDS * 1000)
|
||||
);
|
||||
|
||||
// Check which are still running
|
||||
const stillRunning: typeof remaining = [];
|
||||
@@ -547,7 +778,8 @@ export class ProxmoxAction extends Action {
|
||||
const insecure = this.config.proxmoxInsecure !== false;
|
||||
const baseUrl = `https://${host}:${port}${PROXMOX.API_BASE}`;
|
||||
const headers: Record<string, string> = {
|
||||
'Authorization': `PVEAPIToken=${this.config.proxmoxTokenId}=${this.config.proxmoxTokenSecret}`,
|
||||
'Authorization':
|
||||
`PVEAPIToken=${this.config.proxmoxTokenId}=${this.config.proxmoxTokenSecret}`,
|
||||
};
|
||||
const statusUrl = `${baseUrl}/nodes/${node}/${item.type}/${item.vmid}/status/current`;
|
||||
const response = await this.apiRequest(statusUrl, 'GET', headers, insecure) as {
|
||||
|
||||
@@ -15,6 +15,7 @@ const execFileAsync = promisify(execFile);
|
||||
*/
|
||||
export class ShutdownAction extends Action {
|
||||
readonly type = 'shutdown';
|
||||
private static scheduledDelayMinutes: number | null = null;
|
||||
|
||||
/**
|
||||
* Override shouldExecute to add shutdown-specific safety checks
|
||||
@@ -124,7 +125,26 @@ export class ShutdownAction extends Action {
|
||||
return;
|
||||
}
|
||||
|
||||
const shutdownDelay = this.config.shutdownDelay || SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
const shutdownDelay = this.config.shutdownDelay ?? SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
|
||||
if (
|
||||
ShutdownAction.scheduledDelayMinutes !== null &&
|
||||
ShutdownAction.scheduledDelayMinutes <= shutdownDelay
|
||||
) {
|
||||
logger.info(
|
||||
`Shutdown action skipped: shutdown already scheduled in ${ShutdownAction.scheduledDelayMinutes} minutes`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
ShutdownAction.scheduledDelayMinutes !== null &&
|
||||
ShutdownAction.scheduledDelayMinutes > shutdownDelay
|
||||
) {
|
||||
logger.warn(
|
||||
`Shutdown already scheduled in ${ShutdownAction.scheduledDelayMinutes} minutes, rescheduling to ${shutdownDelay} minutes`,
|
||||
);
|
||||
}
|
||||
|
||||
logger.log('');
|
||||
logger.logBoxTitle('Initiating System Shutdown', UI.WIDE_BOX_WIDTH, 'error');
|
||||
@@ -139,6 +159,7 @@ export class ShutdownAction extends Action {
|
||||
|
||||
try {
|
||||
await this.executeShutdownCommand(shutdownDelay);
|
||||
ShutdownAction.scheduledDelayMinutes = shutdownDelay;
|
||||
} catch (error) {
|
||||
logger.error(
|
||||
`Shutdown command failed: ${error instanceof Error ? error.message : String(error)}`,
|
||||
@@ -227,6 +248,7 @@ export class ShutdownAction extends Action {
|
||||
logger.log(`Trying alternative shutdown method: ${cmdPath} ${alt.args.join(' ')}`);
|
||||
await execFileAsync(cmdPath, alt.args);
|
||||
logger.log(`Alternative method ${alt.cmd} succeeded`);
|
||||
ShutdownAction.scheduledDelayMinutes = 0;
|
||||
return; // Exit if successful
|
||||
}
|
||||
} catch (_altError) {
|
||||
|
||||
+64
-20
@@ -4,6 +4,7 @@ import { type ITableColumn, logger } from '../logger.ts';
|
||||
import { symbols, theme } from '../colors.ts';
|
||||
import type { IActionConfig } from '../actions/base-action.ts';
|
||||
import { ProxmoxAction } from '../actions/proxmox-action.ts';
|
||||
import { SHUTDOWN } from '../constants.ts';
|
||||
import type { IGroupConfig, IUpsConfig } from '../daemon.ts';
|
||||
import * as helpers from '../helpers/index.ts';
|
||||
|
||||
@@ -71,9 +72,13 @@ export class ActionHandler {
|
||||
logger.log(` ${theme.dim('1)')} Shutdown (system shutdown)`);
|
||||
logger.log(` ${theme.dim('2)')} Webhook (HTTP notification)`);
|
||||
logger.log(` ${theme.dim('3)')} Custom Script (run .sh file from /etc/nupst)`);
|
||||
logger.log(` ${theme.dim('4)')} Proxmox (gracefully shut down VMs/LXCs before host shutdown)`);
|
||||
logger.log(
|
||||
` ${theme.dim('4)')} Proxmox (gracefully shut down VMs/LXCs before host shutdown)`,
|
||||
);
|
||||
|
||||
const typeInput = await prompt(` ${theme.dim('Select action type')} ${theme.dim('[1]:')} `);
|
||||
const typeInput = await prompt(
|
||||
` ${theme.dim('Select action type')} ${theme.dim('[1]:')} `,
|
||||
);
|
||||
const typeValue = parseInt(typeInput, 10) || 1;
|
||||
|
||||
const newAction: Partial<IActionConfig> = {};
|
||||
@@ -81,16 +86,22 @@ export class ActionHandler {
|
||||
if (typeValue === 1) {
|
||||
// Shutdown action
|
||||
newAction.type = 'shutdown';
|
||||
const defaultShutdownDelay = this.nupst.getDaemon().getConfig().defaultShutdownDelay ??
|
||||
SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
|
||||
const delayStr = await prompt(
|
||||
` ${theme.dim('Shutdown delay')} ${theme.dim('(minutes) [5]:')} `,
|
||||
` ${theme.dim('Shutdown delay')} ${
|
||||
theme.dim(`(minutes, leave empty for default ${defaultShutdownDelay}):`)
|
||||
} `,
|
||||
);
|
||||
const shutdownDelay = delayStr ? parseInt(delayStr, 10) : 5;
|
||||
if (isNaN(shutdownDelay) || shutdownDelay < 0) {
|
||||
logger.error('Invalid shutdown delay. Must be >= 0.');
|
||||
process.exit(1);
|
||||
if (delayStr.trim()) {
|
||||
const shutdownDelay = parseInt(delayStr, 10);
|
||||
if (isNaN(shutdownDelay) || shutdownDelay < 0) {
|
||||
logger.error('Invalid shutdown delay. Must be >= 0.');
|
||||
process.exit(1);
|
||||
}
|
||||
newAction.shutdownDelay = shutdownDelay;
|
||||
}
|
||||
newAction.shutdownDelay = shutdownDelay;
|
||||
} else if (typeValue === 2) {
|
||||
// Webhook action
|
||||
newAction.type = 'webhook';
|
||||
@@ -109,7 +120,9 @@ export class ActionHandler {
|
||||
const methodInput = await prompt(` ${theme.dim('Select method')} ${theme.dim('[1]:')} `);
|
||||
newAction.webhookMethod = methodInput === '2' ? 'GET' : 'POST';
|
||||
|
||||
const timeoutInput = await prompt(` ${theme.dim('Timeout in seconds')} ${theme.dim('[10]:')} `);
|
||||
const timeoutInput = await prompt(
|
||||
` ${theme.dim('Timeout in seconds')} ${theme.dim('[10]:')} `,
|
||||
);
|
||||
const timeout = parseInt(timeoutInput, 10);
|
||||
if (timeoutInput.trim() && !isNaN(timeout)) {
|
||||
newAction.webhookTimeout = timeout * 1000;
|
||||
@@ -118,14 +131,18 @@ export class ActionHandler {
|
||||
// Script action
|
||||
newAction.type = 'script';
|
||||
|
||||
const scriptPath = await prompt(` ${theme.dim('Script filename (in /etc/nupst/, must end with .sh):')} `);
|
||||
const scriptPath = await prompt(
|
||||
` ${theme.dim('Script filename (in /etc/nupst/, must end with .sh):')} `,
|
||||
);
|
||||
if (!scriptPath.trim() || !scriptPath.trim().endsWith('.sh')) {
|
||||
logger.error('Script path must end with .sh.');
|
||||
process.exit(1);
|
||||
}
|
||||
newAction.scriptPath = scriptPath.trim();
|
||||
|
||||
const timeoutInput = await prompt(` ${theme.dim('Script timeout in seconds')} ${theme.dim('[60]:')} `);
|
||||
const timeoutInput = await prompt(
|
||||
` ${theme.dim('Script timeout in seconds')} ${theme.dim('[60]:')} `,
|
||||
);
|
||||
const timeout = parseInt(timeoutInput, 10);
|
||||
if (timeoutInput.trim() && !isNaN(timeout)) {
|
||||
newAction.scriptTimeout = timeout * 1000;
|
||||
@@ -154,14 +171,20 @@ export class ActionHandler {
|
||||
logger.info('Proxmox API Settings:');
|
||||
logger.dim('Create a token with: pveum user token add root@pam nupst --privsep=0');
|
||||
|
||||
const pxHost = await prompt(` ${theme.dim('Proxmox Host')} ${theme.dim('[localhost]:')} `);
|
||||
const pxHost = await prompt(
|
||||
` ${theme.dim('Proxmox Host')} ${theme.dim('[localhost]:')} `,
|
||||
);
|
||||
newAction.proxmoxHost = pxHost.trim() || 'localhost';
|
||||
|
||||
const pxPortInput = await prompt(` ${theme.dim('Proxmox API Port')} ${theme.dim('[8006]:')} `);
|
||||
const pxPortInput = await prompt(
|
||||
` ${theme.dim('Proxmox API Port')} ${theme.dim('[8006]:')} `,
|
||||
);
|
||||
const pxPort = parseInt(pxPortInput, 10);
|
||||
newAction.proxmoxPort = pxPortInput.trim() && !isNaN(pxPort) ? pxPort : 8006;
|
||||
|
||||
const pxNode = await prompt(` ${theme.dim('Proxmox Node Name (empty = auto-detect):')} `);
|
||||
const pxNode = await prompt(
|
||||
` ${theme.dim('Proxmox Node Name (empty = auto-detect):')} `,
|
||||
);
|
||||
if (pxNode.trim()) {
|
||||
newAction.proxmoxNode = pxNode.trim();
|
||||
}
|
||||
@@ -180,25 +203,41 @@ export class ActionHandler {
|
||||
}
|
||||
newAction.proxmoxTokenSecret = tokenSecret.trim();
|
||||
|
||||
const insecureInput = await prompt(` ${theme.dim('Skip TLS verification (self-signed cert)?')} ${theme.dim('(Y/n):')} `);
|
||||
const insecureInput = await prompt(
|
||||
` ${theme.dim('Skip TLS verification (self-signed cert)?')} ${theme.dim('(Y/n):')} `,
|
||||
);
|
||||
newAction.proxmoxInsecure = insecureInput.toLowerCase() !== 'n';
|
||||
newAction.proxmoxMode = 'api';
|
||||
}
|
||||
|
||||
// Common Proxmox settings (both modes)
|
||||
const excludeInput = await prompt(` ${theme.dim('VM/CT IDs to exclude (comma-separated, or empty):')} `);
|
||||
const excludeInput = await prompt(
|
||||
` ${theme.dim('VM/CT IDs to exclude (comma-separated, or empty):')} `,
|
||||
);
|
||||
if (excludeInput.trim()) {
|
||||
newAction.proxmoxExcludeIds = excludeInput.split(',').map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
|
||||
newAction.proxmoxExcludeIds = excludeInput.split(',').map((s) => parseInt(s.trim(), 10))
|
||||
.filter((n) => !isNaN(n));
|
||||
}
|
||||
|
||||
const timeoutInput = await prompt(` ${theme.dim('VM shutdown timeout in seconds')} ${theme.dim('[120]:')} `);
|
||||
const timeoutInput = await prompt(
|
||||
` ${theme.dim('VM shutdown timeout in seconds')} ${theme.dim('[120]:')} `,
|
||||
);
|
||||
const stopTimeout = parseInt(timeoutInput, 10);
|
||||
if (timeoutInput.trim() && !isNaN(stopTimeout)) {
|
||||
newAction.proxmoxStopTimeout = stopTimeout;
|
||||
}
|
||||
|
||||
const forceInput = await prompt(` ${theme.dim('Force-stop VMs that don\'t shut down in time?')} ${theme.dim('(Y/n):')} `);
|
||||
const forceInput = await prompt(
|
||||
` ${theme.dim("Force-stop VMs that don't shut down in time?")} ${
|
||||
theme.dim('(Y/n):')
|
||||
} `,
|
||||
);
|
||||
newAction.proxmoxForceStop = forceInput.toLowerCase() !== 'n';
|
||||
|
||||
const haPolicyInput = await prompt(
|
||||
` ${theme.dim('HA-managed guest handling')} ${theme.dim('([1] none, 2 haStop):')} `,
|
||||
);
|
||||
newAction.proxmoxHaPolicy = haPolicyInput.trim() === '2' ? 'haStop' : 'none';
|
||||
} else {
|
||||
logger.error('Invalid action type.');
|
||||
process.exit(1);
|
||||
@@ -468,7 +507,9 @@ export class ActionHandler {
|
||||
];
|
||||
|
||||
const rows = target.actions.map((action, index) => {
|
||||
let details = `${action.shutdownDelay || 5}min delay`;
|
||||
const defaultShutdownDelay = this.nupst.getDaemon().getConfig().defaultShutdownDelay ??
|
||||
SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
let details = `${action.shutdownDelay ?? defaultShutdownDelay}min delay`;
|
||||
if (action.type === 'proxmox') {
|
||||
const mode = action.proxmoxMode || 'auto';
|
||||
if (mode === 'cli' || (mode === 'auto' && !action.proxmoxTokenId)) {
|
||||
@@ -481,6 +522,9 @@ export class ActionHandler {
|
||||
if (action.proxmoxExcludeIds?.length) {
|
||||
details += `, excl: ${action.proxmoxExcludeIds.join(',')}`;
|
||||
}
|
||||
if (action.proxmoxHaPolicy === 'haStop') {
|
||||
details += ', haStop';
|
||||
}
|
||||
} else if (action.type === 'webhook') {
|
||||
details = action.webhookUrl || theme.dim('N/A');
|
||||
} else if (action.type === 'script') {
|
||||
|
||||
+16
-5
@@ -10,7 +10,7 @@ import type { TProtocol } from '../protocol/types.ts';
|
||||
import type { INupstConfig, IUpsConfig } from '../daemon.ts';
|
||||
import type { IActionConfig } from '../actions/base-action.ts';
|
||||
import { ProxmoxAction } from '../actions/proxmox-action.ts';
|
||||
import { UPSD } from '../constants.ts';
|
||||
import { SHUTDOWN, UPSD } from '../constants.ts';
|
||||
|
||||
/**
|
||||
* Thresholds configuration for CLI display
|
||||
@@ -1152,11 +1152,19 @@ export class UpsHandler {
|
||||
if (typeValue === 1) {
|
||||
// Shutdown action
|
||||
action.type = 'shutdown';
|
||||
const defaultShutdownDelay = this.nupst.getDaemon().getConfig().defaultShutdownDelay ??
|
||||
SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
|
||||
const delayInput = await prompt('Shutdown delay in minutes [5]: ');
|
||||
const delay = parseInt(delayInput, 10);
|
||||
if (delayInput.trim() && !isNaN(delay)) {
|
||||
action.shutdownDelay = delay;
|
||||
const delayInput = await prompt(
|
||||
`Shutdown delay in minutes (leave empty for default ${defaultShutdownDelay}): `,
|
||||
);
|
||||
if (delayInput.trim()) {
|
||||
const delay = parseInt(delayInput, 10);
|
||||
if (isNaN(delay) || delay < 0) {
|
||||
logger.warn('Invalid shutdown delay, using configured default');
|
||||
} else {
|
||||
action.shutdownDelay = delay;
|
||||
}
|
||||
}
|
||||
} else if (typeValue === 2) {
|
||||
// Webhook action
|
||||
@@ -1268,6 +1276,9 @@ export class UpsHandler {
|
||||
const forceInput = await prompt("Force-stop VMs that don't shut down in time? (Y/n): ");
|
||||
action.proxmoxForceStop = forceInput.toLowerCase() !== 'n';
|
||||
|
||||
const haPolicyInput = await prompt('HA-managed guest handling ([1] none, 2 haStop): ');
|
||||
action.proxmoxHaPolicy = haPolicyInput.trim() === '2' ? 'haStop' : 'none';
|
||||
|
||||
logger.log('');
|
||||
logger.info('Note: Place the Proxmox action BEFORE the shutdown action');
|
||||
logger.dim('in the action chain so VMs shut down before the host.');
|
||||
|
||||
+204
-18
@@ -12,9 +12,14 @@ import { MigrationRunner } from './migrations/index.ts';
|
||||
import { formatPowerStatus, getBatteryColor, getRuntimeColor, theme } from './colors.ts';
|
||||
import type { IActionConfig } from './actions/base-action.ts';
|
||||
import { ActionManager } from './actions/index.ts';
|
||||
import { decideUpsActionExecution, type TUpsTriggerReason } from './action-orchestration.ts';
|
||||
import {
|
||||
applyDefaultShutdownDelay,
|
||||
buildUpsActionContext,
|
||||
decideUpsActionExecution,
|
||||
type TUpsTriggerReason,
|
||||
} from './action-orchestration.ts';
|
||||
import { NupstHttpServer } from './http-server.ts';
|
||||
import { NETWORK, PAUSE, THRESHOLDS, TIMING, UI } from './constants.ts';
|
||||
import { NETWORK, PAUSE, SHUTDOWN, THRESHOLDS, TIMING, UI } from './constants.ts';
|
||||
import {
|
||||
analyzeConfigReload,
|
||||
shouldRefreshPauseState,
|
||||
@@ -22,11 +27,17 @@ import {
|
||||
} from './config-watch.ts';
|
||||
import { type IPauseState, loadPauseSnapshot } from './pause-state.ts';
|
||||
import { ShutdownExecutor } from './shutdown-executor.ts';
|
||||
import {
|
||||
buildGroupStatusSnapshot,
|
||||
buildGroupThresholdContextStatus,
|
||||
evaluateGroupActionThreshold,
|
||||
} from './group-monitoring.ts';
|
||||
import {
|
||||
buildFailedUpsPollSnapshot,
|
||||
buildSuccessfulUpsPollSnapshot,
|
||||
ensureUpsStatus,
|
||||
hasThresholdViolation,
|
||||
getActionThresholdStates,
|
||||
getEnteredThresholdIndexes,
|
||||
} from './ups-monitoring.ts';
|
||||
import {
|
||||
buildShutdownErrorRow,
|
||||
@@ -97,6 +108,8 @@ export interface INupstConfig {
|
||||
groups: IGroupConfig[];
|
||||
/** Check interval in milliseconds */
|
||||
checkInterval: number;
|
||||
/** Default delay in minutes for shutdown actions without an override */
|
||||
defaultShutdownDelay?: number;
|
||||
/** HTTP Server configuration */
|
||||
httpServer?: IHttpServerConfig;
|
||||
|
||||
@@ -125,6 +138,7 @@ export class NupstDaemon {
|
||||
/** Default configuration */
|
||||
private readonly DEFAULT_CONFIG: INupstConfig = {
|
||||
version: '4.3',
|
||||
defaultShutdownDelay: SHUTDOWN.DEFAULT_DELAY_MINUTES,
|
||||
upsDevices: [
|
||||
{
|
||||
id: 'default',
|
||||
@@ -155,7 +169,6 @@ export class NupstDaemon {
|
||||
battery: THRESHOLDS.DEFAULT_BATTERY_PERCENT, // Shutdown when battery below 60%
|
||||
runtime: THRESHOLDS.DEFAULT_RUNTIME_MINUTES, // Shutdown when runtime below 20 minutes
|
||||
},
|
||||
shutdownDelay: 5,
|
||||
},
|
||||
],
|
||||
},
|
||||
@@ -172,6 +185,8 @@ export class NupstDaemon {
|
||||
private isPaused: boolean = false;
|
||||
private pauseState: IPauseState | null = null;
|
||||
private upsStatus: Map<string, IUpsStatus> = new Map();
|
||||
private groupStatus: Map<string, IUpsStatus> = new Map();
|
||||
private thresholdState: Map<string, boolean[]> = new Map();
|
||||
private httpServer?: NupstHttpServer;
|
||||
private readonly shutdownExecutor: ShutdownExecutor;
|
||||
|
||||
@@ -208,10 +223,14 @@ export class NupstDaemon {
|
||||
const migrationRunner = new MigrationRunner();
|
||||
const { config: migratedConfig, migrated } = await migrationRunner.run(parsedConfig);
|
||||
|
||||
// Save migrated config back to disk if any migrations ran
|
||||
// Cast to INupstConfig since migrations ensure the output is valid
|
||||
// Save migrated or normalized config back to disk when needed.
|
||||
// Cast to INupstConfig since migrations ensure the output is valid.
|
||||
const validConfig = migratedConfig as unknown as INupstConfig;
|
||||
if (migrated) {
|
||||
const normalizedShutdownDelay = this.normalizeShutdownDelay(validConfig.defaultShutdownDelay);
|
||||
const shouldPersistNormalizedConfig =
|
||||
validConfig.defaultShutdownDelay !== normalizedShutdownDelay;
|
||||
validConfig.defaultShutdownDelay = normalizedShutdownDelay;
|
||||
if (migrated || shouldPersistNormalizedConfig) {
|
||||
this.config = validConfig;
|
||||
await this.saveConfig(this.config);
|
||||
} else {
|
||||
@@ -249,6 +268,7 @@ export class NupstDaemon {
|
||||
upsDevices: config.upsDevices,
|
||||
groups: config.groups,
|
||||
checkInterval: config.checkInterval,
|
||||
defaultShutdownDelay: this.normalizeShutdownDelay(config.defaultShutdownDelay),
|
||||
...(config.httpServer ? { httpServer: config.httpServer } : {}),
|
||||
};
|
||||
|
||||
@@ -280,6 +300,22 @@ export class NupstDaemon {
|
||||
return this.config;
|
||||
}
|
||||
|
||||
private normalizeShutdownDelay(delayMinutes: number | undefined): number {
|
||||
if (
|
||||
typeof delayMinutes !== 'number' ||
|
||||
!Number.isFinite(delayMinutes) ||
|
||||
delayMinutes < 0
|
||||
) {
|
||||
return SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
}
|
||||
|
||||
return delayMinutes;
|
||||
}
|
||||
|
||||
private getDefaultShutdownDelayMinutes(): number {
|
||||
return this.normalizeShutdownDelay(this.config.defaultShutdownDelay);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SNMP instance
|
||||
*/
|
||||
@@ -616,19 +652,24 @@ export class NupstDaemon {
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
hasThresholdViolation(
|
||||
status.powerStatus,
|
||||
status.batteryCapacity,
|
||||
status.batteryRuntime,
|
||||
ups.actions,
|
||||
)
|
||||
) {
|
||||
const thresholdStates = getActionThresholdStates(
|
||||
status.powerStatus,
|
||||
status.batteryCapacity,
|
||||
status.batteryRuntime,
|
||||
ups.actions,
|
||||
);
|
||||
const enteredThresholdIndexes = this.trackEnteredThresholdIndexes(
|
||||
`ups:${ups.id}`,
|
||||
thresholdStates,
|
||||
);
|
||||
|
||||
if (enteredThresholdIndexes.length > 0) {
|
||||
await this.triggerUpsActions(
|
||||
ups,
|
||||
pollSnapshot.updatedStatus,
|
||||
pollSnapshot.previousStatus,
|
||||
'thresholdViolation',
|
||||
enteredThresholdIndexes,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -668,6 +709,95 @@ export class NupstDaemon {
|
||||
this.upsStatus.set(ups.id, failureSnapshot.updatedStatus);
|
||||
}
|
||||
}
|
||||
|
||||
await this.checkGroupActions();
|
||||
}
|
||||
|
||||
private trackEnteredThresholdIndexes(sourceKey: string, currentStates: boolean[]): number[] {
|
||||
const previousStates = this.thresholdState.get(sourceKey);
|
||||
const enteredIndexes = getEnteredThresholdIndexes(previousStates, currentStates);
|
||||
this.thresholdState.set(sourceKey, [...currentStates]);
|
||||
return enteredIndexes;
|
||||
}
|
||||
|
||||
private getGroupActionIdentity(group: IGroupConfig): { id: string; name: string } {
|
||||
return {
|
||||
id: group.id,
|
||||
name: `Group ${group.name}`,
|
||||
};
|
||||
}
|
||||
|
||||
private async checkGroupActions(): Promise<void> {
|
||||
for (const group of this.config.groups || []) {
|
||||
const groupIdentity = this.getGroupActionIdentity(group);
|
||||
const memberStatuses = this.config.upsDevices
|
||||
.filter((ups) => ups.groups?.includes(group.id))
|
||||
.map((ups) => this.upsStatus.get(ups.id))
|
||||
.filter((status): status is IUpsStatus => !!status);
|
||||
|
||||
if (memberStatuses.length === 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const currentTime = Date.now();
|
||||
const pollSnapshot = buildGroupStatusSnapshot(
|
||||
groupIdentity,
|
||||
group.mode,
|
||||
memberStatuses,
|
||||
this.groupStatus.get(group.id),
|
||||
currentTime,
|
||||
);
|
||||
|
||||
if (pollSnapshot.transition === 'powerStatusChange' && pollSnapshot.previousStatus) {
|
||||
logger.log('');
|
||||
logger.logBoxTitle(`Group Power Status Change: ${group.name}`, 60, 'warning');
|
||||
logger.logBoxLine(
|
||||
`Previous: ${formatPowerStatus(pollSnapshot.previousStatus.powerStatus)}`,
|
||||
);
|
||||
logger.logBoxLine(`Current: ${formatPowerStatus(pollSnapshot.updatedStatus.powerStatus)}`);
|
||||
logger.logBoxLine(`Members: ${memberStatuses.map((status) => status.name).join(', ')}`);
|
||||
logger.logBoxLine(`Time: ${new Date().toISOString()}`);
|
||||
logger.logBoxEnd();
|
||||
logger.log('');
|
||||
|
||||
await this.triggerGroupActions(
|
||||
group,
|
||||
pollSnapshot.updatedStatus,
|
||||
pollSnapshot.previousStatus,
|
||||
'powerStatusChange',
|
||||
);
|
||||
}
|
||||
|
||||
const thresholdEvaluations = (group.actions || []).map((action) =>
|
||||
evaluateGroupActionThreshold(action, group.mode, memberStatuses)
|
||||
);
|
||||
const thresholdStates = thresholdEvaluations.map((evaluation) =>
|
||||
evaluation.exceedsThreshold && !evaluation.blockedByUnreachable
|
||||
);
|
||||
const enteredThresholdIndexes = this.trackEnteredThresholdIndexes(
|
||||
`group:${group.id}`,
|
||||
thresholdStates,
|
||||
);
|
||||
|
||||
if (enteredThresholdIndexes.length > 0) {
|
||||
const thresholdStatus = buildGroupThresholdContextStatus(
|
||||
groupIdentity,
|
||||
thresholdEvaluations,
|
||||
enteredThresholdIndexes,
|
||||
pollSnapshot.updatedStatus,
|
||||
currentTime,
|
||||
);
|
||||
await this.triggerGroupActions(
|
||||
group,
|
||||
thresholdStatus,
|
||||
pollSnapshot.previousStatus,
|
||||
'thresholdViolation',
|
||||
enteredThresholdIndexes,
|
||||
);
|
||||
}
|
||||
|
||||
this.groupStatus.set(group.id, pollSnapshot.updatedStatus);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -735,6 +865,7 @@ export class NupstDaemon {
|
||||
status: IUpsStatus,
|
||||
previousStatus: IUpsStatus | undefined,
|
||||
triggerReason: TUpsTriggerReason,
|
||||
actionIndexes?: number[],
|
||||
): Promise<void> {
|
||||
const decision = decideUpsActionExecution(
|
||||
this.isPaused,
|
||||
@@ -758,7 +889,61 @@ export class NupstDaemon {
|
||||
return;
|
||||
}
|
||||
|
||||
await ActionManager.executeActions(decision.actions, decision.context);
|
||||
const selectedActions = actionIndexes
|
||||
? decision.actions.filter((_action, index) => actionIndexes.includes(index))
|
||||
: decision.actions;
|
||||
|
||||
if (selectedActions.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const actions = applyDefaultShutdownDelay(
|
||||
selectedActions,
|
||||
this.getDefaultShutdownDelayMinutes(),
|
||||
);
|
||||
|
||||
await ActionManager.executeActions(actions, decision.context);
|
||||
}
|
||||
|
||||
private async triggerGroupActions(
|
||||
group: IGroupConfig,
|
||||
status: IUpsStatus,
|
||||
previousStatus: IUpsStatus | undefined,
|
||||
triggerReason: TUpsTriggerReason,
|
||||
actionIndexes?: number[],
|
||||
): Promise<void> {
|
||||
if (this.isPaused) {
|
||||
logger.info(
|
||||
`[PAUSED] Actions suppressed for Group ${group.name} (trigger: ${triggerReason})`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
const configuredActions = group.actions || [];
|
||||
if (configuredActions.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const selectedActions = actionIndexes
|
||||
? configuredActions.filter((_action, index) => actionIndexes.includes(index))
|
||||
: configuredActions;
|
||||
|
||||
if (selectedActions.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const actions = applyDefaultShutdownDelay(
|
||||
selectedActions,
|
||||
this.getDefaultShutdownDelayMinutes(),
|
||||
);
|
||||
const context = buildUpsActionContext(
|
||||
this.getGroupActionIdentity(group),
|
||||
status,
|
||||
previousStatus,
|
||||
triggerReason,
|
||||
);
|
||||
|
||||
await ActionManager.executeActions(actions, context);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -768,8 +953,7 @@ export class NupstDaemon {
|
||||
public async initiateShutdown(reason: string): Promise<void> {
|
||||
logger.log(`Initiating system shutdown due to: ${reason}`);
|
||||
|
||||
// Set a longer delay for shutdown to allow VMs and services to close
|
||||
const shutdownDelayMinutes = 5;
|
||||
const shutdownDelayMinutes = this.getDefaultShutdownDelayMinutes();
|
||||
|
||||
try {
|
||||
await this.shutdownExecutor.scheduleShutdown(shutdownDelayMinutes);
|
||||
@@ -1024,6 +1208,8 @@ export class NupstDaemon {
|
||||
|
||||
// Load the new configuration
|
||||
await this.loadConfig();
|
||||
this.thresholdState.clear();
|
||||
this.groupStatus.clear();
|
||||
const newDeviceCount = this.config.upsDevices?.length || 0;
|
||||
|
||||
const reloadSnapshot = analyzeConfigReload(oldDeviceCount, newDeviceCount);
|
||||
|
||||
@@ -0,0 +1,198 @@
|
||||
import type { IActionConfig, TPowerStatus } from './actions/base-action.ts';
|
||||
import { createInitialUpsStatus, type IUpsIdentity, type IUpsStatus } from './ups-status.ts';
|
||||
|
||||
export interface IGroupStatusSnapshot {
|
||||
updatedStatus: IUpsStatus;
|
||||
transition: 'none' | 'powerStatusChange';
|
||||
previousStatus?: IUpsStatus;
|
||||
}
|
||||
|
||||
export interface IGroupThresholdEvaluation {
|
||||
exceedsThreshold: boolean;
|
||||
blockedByUnreachable: boolean;
|
||||
representativeStatus?: IUpsStatus;
|
||||
}
|
||||
|
||||
const destructiveActionTypes = new Set(['shutdown', 'proxmox']);
|
||||
|
||||
function getStatusSeverity(powerStatus: TPowerStatus): number {
|
||||
switch (powerStatus) {
|
||||
case 'unreachable':
|
||||
return 3;
|
||||
case 'onBattery':
|
||||
return 2;
|
||||
case 'unknown':
|
||||
return 1;
|
||||
case 'online':
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
export function selectWorstStatus(statuses: IUpsStatus[]): IUpsStatus | undefined {
|
||||
return statuses.reduce<IUpsStatus | undefined>((worst, status) => {
|
||||
if (!worst) {
|
||||
return status;
|
||||
}
|
||||
|
||||
const severityDiff = getStatusSeverity(status.powerStatus) -
|
||||
getStatusSeverity(worst.powerStatus);
|
||||
if (severityDiff > 0) {
|
||||
return status;
|
||||
}
|
||||
if (severityDiff < 0) {
|
||||
return worst;
|
||||
}
|
||||
|
||||
if (status.batteryRuntime !== worst.batteryRuntime) {
|
||||
return status.batteryRuntime < worst.batteryRuntime ? status : worst;
|
||||
}
|
||||
|
||||
if (status.batteryCapacity !== worst.batteryCapacity) {
|
||||
return status.batteryCapacity < worst.batteryCapacity ? status : worst;
|
||||
}
|
||||
|
||||
return worst;
|
||||
}, undefined);
|
||||
}
|
||||
|
||||
function deriveGroupPowerStatus(
|
||||
mode: 'redundant' | 'nonRedundant',
|
||||
memberStatuses: IUpsStatus[],
|
||||
): TPowerStatus {
|
||||
if (memberStatuses.length === 0) {
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
if (memberStatuses.some((status) => status.powerStatus === 'unreachable')) {
|
||||
return 'unreachable';
|
||||
}
|
||||
|
||||
if (mode === 'redundant') {
|
||||
if (memberStatuses.every((status) => status.powerStatus === 'onBattery')) {
|
||||
return 'onBattery';
|
||||
}
|
||||
} else if (memberStatuses.some((status) => status.powerStatus === 'onBattery')) {
|
||||
return 'onBattery';
|
||||
}
|
||||
|
||||
if (memberStatuses.some((status) => status.powerStatus === 'unknown')) {
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
return 'online';
|
||||
}
|
||||
|
||||
function pickRepresentativeStatus(
|
||||
powerStatus: TPowerStatus,
|
||||
memberStatuses: IUpsStatus[],
|
||||
): IUpsStatus | undefined {
|
||||
const matchingStatuses = memberStatuses.filter((status) => status.powerStatus === powerStatus);
|
||||
return selectWorstStatus(matchingStatuses.length > 0 ? matchingStatuses : memberStatuses);
|
||||
}
|
||||
|
||||
export function buildGroupStatusSnapshot(
|
||||
group: IUpsIdentity,
|
||||
mode: 'redundant' | 'nonRedundant',
|
||||
memberStatuses: IUpsStatus[],
|
||||
currentStatus: IUpsStatus | undefined,
|
||||
currentTime: number,
|
||||
): IGroupStatusSnapshot {
|
||||
const previousStatus = currentStatus || createInitialUpsStatus(group, currentTime);
|
||||
const powerStatus = deriveGroupPowerStatus(mode, memberStatuses);
|
||||
const representative = pickRepresentativeStatus(powerStatus, memberStatuses) || previousStatus;
|
||||
const updatedStatus: IUpsStatus = {
|
||||
...previousStatus,
|
||||
id: group.id,
|
||||
name: group.name,
|
||||
powerStatus,
|
||||
batteryCapacity: representative.batteryCapacity,
|
||||
batteryRuntime: representative.batteryRuntime,
|
||||
outputLoad: representative.outputLoad,
|
||||
outputPower: representative.outputPower,
|
||||
outputVoltage: representative.outputVoltage,
|
||||
outputCurrent: representative.outputCurrent,
|
||||
lastCheckTime: currentTime,
|
||||
consecutiveFailures: 0,
|
||||
unreachableSince: powerStatus === 'unreachable'
|
||||
? previousStatus.unreachableSince || currentTime
|
||||
: 0,
|
||||
lastStatusChange: previousStatus.lastStatusChange || currentTime,
|
||||
};
|
||||
|
||||
if (previousStatus.powerStatus !== powerStatus) {
|
||||
updatedStatus.lastStatusChange = currentTime;
|
||||
if (powerStatus === 'unreachable') {
|
||||
updatedStatus.unreachableSince = currentTime;
|
||||
}
|
||||
return {
|
||||
updatedStatus,
|
||||
transition: 'powerStatusChange',
|
||||
previousStatus,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
updatedStatus,
|
||||
transition: 'none',
|
||||
previousStatus: currentStatus,
|
||||
};
|
||||
}
|
||||
|
||||
export function evaluateGroupActionThreshold(
|
||||
actionConfig: IActionConfig,
|
||||
mode: 'redundant' | 'nonRedundant',
|
||||
memberStatuses: IUpsStatus[],
|
||||
): IGroupThresholdEvaluation {
|
||||
if (!actionConfig.thresholds || memberStatuses.length === 0) {
|
||||
return {
|
||||
exceedsThreshold: false,
|
||||
blockedByUnreachable: false,
|
||||
};
|
||||
}
|
||||
|
||||
const criticalMembers = memberStatuses.filter((status) =>
|
||||
status.powerStatus === 'onBattery' &&
|
||||
(status.batteryCapacity < actionConfig.thresholds!.battery ||
|
||||
status.batteryRuntime < actionConfig.thresholds!.runtime)
|
||||
);
|
||||
const exceedsThreshold = mode === 'redundant'
|
||||
? criticalMembers.length === memberStatuses.length
|
||||
: criticalMembers.length > 0;
|
||||
|
||||
return {
|
||||
exceedsThreshold,
|
||||
blockedByUnreachable: exceedsThreshold &&
|
||||
destructiveActionTypes.has(actionConfig.type) &&
|
||||
memberStatuses.some((status) => status.powerStatus === 'unreachable'),
|
||||
representativeStatus: selectWorstStatus(criticalMembers),
|
||||
};
|
||||
}
|
||||
|
||||
export function buildGroupThresholdContextStatus(
|
||||
group: IUpsIdentity,
|
||||
evaluations: IGroupThresholdEvaluation[],
|
||||
enteredActionIndexes: number[],
|
||||
fallbackStatus: IUpsStatus,
|
||||
currentTime: number,
|
||||
): IUpsStatus {
|
||||
const representativeStatuses = enteredActionIndexes
|
||||
.map((index) => evaluations[index]?.representativeStatus)
|
||||
.filter((status): status is IUpsStatus => !!status);
|
||||
|
||||
const representative = selectWorstStatus(representativeStatuses) || fallbackStatus;
|
||||
|
||||
return {
|
||||
...fallbackStatus,
|
||||
id: group.id,
|
||||
name: group.name,
|
||||
powerStatus: 'onBattery',
|
||||
batteryCapacity: representative.batteryCapacity,
|
||||
batteryRuntime: representative.batteryRuntime,
|
||||
outputLoad: representative.outputLoad,
|
||||
outputPower: representative.outputPower,
|
||||
outputVoltage: representative.outputVoltage,
|
||||
outputCurrent: representative.outputCurrent,
|
||||
lastCheckTime: currentTime,
|
||||
};
|
||||
}
|
||||
@@ -37,8 +37,7 @@ import { logger } from '../logger.ts';
|
||||
* {
|
||||
* type: "shutdown",
|
||||
* thresholds: { battery: 60, runtime: 20 },
|
||||
* triggerMode: "onlyThresholds",
|
||||
* shutdownDelay: 5
|
||||
* triggerMode: "onlyThresholds"
|
||||
* }
|
||||
* ]
|
||||
* }
|
||||
@@ -93,7 +92,6 @@ export class MigrationV4_0ToV4_1 extends BaseMigration {
|
||||
runtime: deviceThresholds.runtime,
|
||||
},
|
||||
triggerMode: 'onlyThresholds', // Preserve old behavior (only on threshold violation)
|
||||
shutdownDelay: 5, // Default delay
|
||||
},
|
||||
];
|
||||
logger.dim(
|
||||
|
||||
+24
-9
@@ -5,6 +5,7 @@ import { type IUpsConfig, NupstDaemon } from './daemon.ts';
|
||||
import { NupstSnmp } from './snmp/manager.ts';
|
||||
import { logger } from './logger.ts';
|
||||
import { formatPowerStatus, getBatteryColor, getRuntimeColor, symbols, theme } from './colors.ts';
|
||||
import { SHUTDOWN } from './constants.ts';
|
||||
|
||||
/**
|
||||
* Class for managing systemd service
|
||||
@@ -316,7 +317,6 @@ WantedBy=multi-user.target
|
||||
type: 'shutdown',
|
||||
thresholds: config.thresholds,
|
||||
triggerMode: 'onlyThresholds',
|
||||
shutdownDelay: 5,
|
||||
},
|
||||
]
|
||||
: [],
|
||||
@@ -346,6 +346,8 @@ WantedBy=multi-user.target
|
||||
*/
|
||||
private async displaySingleUpsStatus(ups: IUpsConfig, snmp: NupstSnmp): Promise<void> {
|
||||
try {
|
||||
const defaultShutdownDelay = this.daemon.getConfig().defaultShutdownDelay ??
|
||||
SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
const protocol = ups.protocol || 'snmp';
|
||||
let status;
|
||||
|
||||
@@ -432,14 +434,20 @@ WantedBy=multi-user.target
|
||||
actionDesc += ` (${
|
||||
action.triggerMode || 'onlyThresholds'
|
||||
}: battery<${action.thresholds.battery}%, runtime<${action.thresholds.runtime}min`;
|
||||
if (action.shutdownDelay) {
|
||||
actionDesc += `, delay=${action.shutdownDelay}s`;
|
||||
if (action.type === 'shutdown') {
|
||||
const shutdownDelay = action.shutdownDelay ?? defaultShutdownDelay;
|
||||
actionDesc += `, delay=${shutdownDelay}min`;
|
||||
} else if (action.type === 'proxmox' && action.proxmoxHaPolicy === 'haStop') {
|
||||
actionDesc += ', ha=stop';
|
||||
}
|
||||
actionDesc += ')';
|
||||
} else {
|
||||
actionDesc += ` (${action.triggerMode || 'onlyPowerChanges'}`;
|
||||
if (action.shutdownDelay) {
|
||||
actionDesc += `, delay=${action.shutdownDelay}s`;
|
||||
if (action.type === 'shutdown') {
|
||||
const shutdownDelay = action.shutdownDelay ?? defaultShutdownDelay;
|
||||
actionDesc += `, delay=${shutdownDelay}min`;
|
||||
} else if (action.type === 'proxmox' && action.proxmoxHaPolicy === 'haStop') {
|
||||
actionDesc += ', ha=stop';
|
||||
}
|
||||
actionDesc += ')';
|
||||
}
|
||||
@@ -506,20 +514,27 @@ WantedBy=multi-user.target
|
||||
|
||||
// Display actions if any
|
||||
if (group.actions && group.actions.length > 0) {
|
||||
const defaultShutdownDelay = config.defaultShutdownDelay ?? SHUTDOWN.DEFAULT_DELAY_MINUTES;
|
||||
for (const action of group.actions) {
|
||||
let actionDesc = `${action.type}`;
|
||||
if (action.thresholds) {
|
||||
actionDesc += ` (${
|
||||
action.triggerMode || 'onlyThresholds'
|
||||
}: battery<${action.thresholds.battery}%, runtime<${action.thresholds.runtime}min`;
|
||||
if (action.shutdownDelay) {
|
||||
actionDesc += `, delay=${action.shutdownDelay}s`;
|
||||
if (action.type === 'shutdown') {
|
||||
const shutdownDelay = action.shutdownDelay ?? defaultShutdownDelay;
|
||||
actionDesc += `, delay=${shutdownDelay}min`;
|
||||
} else if (action.type === 'proxmox' && action.proxmoxHaPolicy === 'haStop') {
|
||||
actionDesc += ', ha=stop';
|
||||
}
|
||||
actionDesc += ')';
|
||||
} else {
|
||||
actionDesc += ` (${action.triggerMode || 'onlyPowerChanges'}`;
|
||||
if (action.shutdownDelay) {
|
||||
actionDesc += `, delay=${action.shutdownDelay}s`;
|
||||
if (action.type === 'shutdown') {
|
||||
const shutdownDelay = action.shutdownDelay ?? defaultShutdownDelay;
|
||||
actionDesc += `, delay=${shutdownDelay}min`;
|
||||
} else if (action.type === 'proxmox' && action.proxmoxHaPolicy === 'haStop') {
|
||||
actionDesc += ', ha=stop';
|
||||
}
|
||||
actionDesc += ')';
|
||||
}
|
||||
|
||||
+43
-9
@@ -120,19 +120,53 @@ export function hasThresholdViolation(
|
||||
batteryRuntime: number,
|
||||
actions: IActionConfig[] | undefined,
|
||||
): boolean {
|
||||
if (powerStatus !== 'onBattery' || !actions || actions.length === 0) {
|
||||
return getActionThresholdStates(powerStatus, batteryCapacity, batteryRuntime, actions).some(
|
||||
Boolean,
|
||||
);
|
||||
}
|
||||
|
||||
export function isActionThresholdExceeded(
|
||||
actionConfig: IActionConfig,
|
||||
powerStatus: IProtocolUpsStatus['powerStatus'],
|
||||
batteryCapacity: number,
|
||||
batteryRuntime: number,
|
||||
): boolean {
|
||||
if (powerStatus !== 'onBattery' || !actionConfig.thresholds) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (const actionConfig of actions) {
|
||||
if (
|
||||
actionConfig.thresholds &&
|
||||
(batteryCapacity < actionConfig.thresholds.battery ||
|
||||
batteryRuntime < actionConfig.thresholds.runtime)
|
||||
) {
|
||||
return true;
|
||||
return (
|
||||
batteryCapacity < actionConfig.thresholds.battery ||
|
||||
batteryRuntime < actionConfig.thresholds.runtime
|
||||
);
|
||||
}
|
||||
|
||||
export function getActionThresholdStates(
|
||||
powerStatus: IProtocolUpsStatus['powerStatus'],
|
||||
batteryCapacity: number,
|
||||
batteryRuntime: number,
|
||||
actions: IActionConfig[] | undefined,
|
||||
): boolean[] {
|
||||
if (!actions || actions.length === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return actions.map((actionConfig) =>
|
||||
isActionThresholdExceeded(actionConfig, powerStatus, batteryCapacity, batteryRuntime)
|
||||
);
|
||||
}
|
||||
|
||||
export function getEnteredThresholdIndexes(
|
||||
previousStates: boolean[] | undefined,
|
||||
currentStates: boolean[],
|
||||
): number[] {
|
||||
const enteredIndexes: number[] = [];
|
||||
|
||||
for (let index = 0; index < currentStates.length; index++) {
|
||||
if (currentStates[index] && !previousStates?.[index]) {
|
||||
enteredIndexes.push(index);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return enteredIndexes;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user