ExternalVendorCode/balena-supervisor
1
0
Fork 0
mirror of https://github.com/balena-os/balena-supervisor.git synced 2025-05-04 18:12:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Make service-manager module a singleton

Browse Source 
Change-type: patch
Signed-off-by: Cameron Diver <cameron@balena.io>
This commit is contained in:
Cameron Diver 2020-06-15 11:31:26 +01:00 committed by Balena CI
parent adaad786af
commit 0e8d92e08a
7 changed files with 588 additions and 601 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/application-manager.d.ts vendored
View File

@ -7,7 +7,6 @@ import { ServiceAction } from './device-api/common';
import { DeviceStatus, InstancedAppState } from './types/state';
import type { Image } from './compose/images';
import ServiceManager from './compose/service-manager';
import DeviceState from './device-state';
import { APIBinder } from './api-binder';
@ -45,8 +44,6 @@ class ApplicationManager extends EventEmitter {
public deviceState: DeviceState;
public apiBinder: APIBinder;
public services: ServiceManager;
public proxyvisor: any;
public timeSpentFetching: number;
public fetchesInProgress: number;

22
src/application-manager.js
View File

@ -21,11 +21,11 @@ import {
import * as dbFormat from './device-state/db-format';
import { ServiceManager } from './compose/service-manager';
import * as Images from './compose/images';
import { Network } from './compose/network';
import * as networkManager from './compose/network-manager';
import * as volumeManager from './compose/volume-manager';
import * as serviceManager from './compose/service-manager';
import * as compositionSteps from './compose/composition-steps';
import { Proxyvisor } from './proxyvisor';
@ -159,7 +159,6 @@ export class ApplicationManager extends EventEmitter {
this.deviceState = deviceState;
this.apiBinder = apiBinder;
this.services = new ServiceManager();
this.proxyvisor = new Proxyvisor({
applications: this,
});
@ -171,7 +170,6 @@ export class ApplicationManager extends EventEmitter {
this.actionExecutors = compositionSteps.getExecutors({
lockFn: this._lockingIfNecessary,
services: this.services,
applications: this,
callbacks: {
containerStarted: (id) => {
@ -198,7 +196,7 @@ export class ApplicationManager extends EventEmitter {
);
this.router = createApplicationManagerRouter(this);
Images.on('change', this.reportCurrentState);
this.services.on('change', this.reportCurrentState);
serviceManager.on('change', this.reportCurrentState);
}
reportCurrentState(data) {
@ -223,14 +221,14 @@ export class ApplicationManager extends EventEmitter {
// But also run it in on startup
await cleanup();
await this.localModeManager.init();
await this.services.attachToRunning();
await this.services.listenToEvents();
await serviceManager.attachToRunning();
await serviceManager.listenToEvents();
}
// Returns the status of applications and their services
getStatus() {
return Promise.join(
this.services.getStatus(),
serviceManager.getStatus(),
Images.getStatus(),
config.get('currentCommit'),
function (services, images, currentCommit) {
@ -362,7 +360,7 @@ export class ApplicationManager extends EventEmitter {
getCurrentForComparison() {
return Promise.join(
this.services.getAll(),
serviceManager.getAll(),
networkManager.getAll(),
volumeManager.getAll(),
config.get('currentCommit'),
@ -372,7 +370,7 @@ export class ApplicationManager extends EventEmitter {
getCurrentApp(appId) {
return Promise.join(
this.services.getAllByAppId(appId),
serviceManager.getAllByAppId(appId),
networkManager.getAllByAppId(appId),
volumeManager.getAllByAppId(appId),
config.get('currentCommit'),
@ -1339,13 +1337,13 @@ export class ApplicationManager extends EventEmitter {
}
stopAll({ force = false, skipLock = false } = {}) {
return Promise.resolve(this.services.getAll())
return Promise.resolve(serviceManager.getAll())
.map((service) => {
return this._lockingIfNecessary(
service.appId,
{ force, skipLock },
() => {
return this.services
return serviceManager
.kill(service, { removeContainer: false, wait: true })
.then(() => {
delete this._containerStarted[service.containerId];
@ -1391,7 +1389,7 @@ export class ApplicationManager extends EventEmitter {
if (intId == null) {
throw new Error(`Invalid id: ${id}`);
}
containerIdsByAppId[intId] = this.services.getContainerIdMap(intId);
containerIdsByAppId[intId] = serviceManager.getContainerIdMap(intId);
});
return config.get('localMode').then((localMode) => {

19
src/compose/composition-steps.ts
View File

@ -7,7 +7,7 @@ import type { Image } from './images';
import * as images from './images';
import Network from './network';
import Service from './service';
import ServiceManager from './service-manager';
import * as serviceManager from './service-manager';
import Volume from './volume';
import { checkTruthy } from '../lib/validation';
@ -136,7 +136,6 @@ interface CompositionCallbacks {
export function getExecutors(app: {
lockFn: LockingFn;
services: ServiceManager;
applications: ApplicationManager;
callbacks: CompositionCallbacks;
}) {
@ -150,7 +149,7 @@ export function getExecutors(app: {
},
async () => {
const wait = _.get(step, ['options', 'wait'], false);
await app.services.kill(step.current, {
await serviceManager.kill(step.current, {
removeContainer: false,
wait,
});
@ -166,7 +165,7 @@ export function getExecutors(app: {
skipLock: step.skipLock || _.get(step, ['options', 'skipLock']),
},
async () => {
await app.services.kill(step.current);
await serviceManager.kill(step.current);
app.callbacks.containerKilled(step.current.containerId);
if (_.get(step, ['options', 'removeImage'])) {
await images.removeByDockerId(step.current.config.image);
@ -177,7 +176,7 @@ export function getExecutors(app: {
remove: async (step) => {
// Only called for dead containers, so no need to
// take locks
await app.services.remove(step.current);
await serviceManager.remove(step.current);
},
updateMetadata: (step) => {
const skipLock =
@ -190,7 +189,7 @@ export function getExecutors(app: {
skipLock: skipLock || _.get(step, ['options', 'skipLock']),
},
async () => {
await app.services.updateMetadata(step.current, step.target);
await serviceManager.updateMetadata(step.current, step.target);
},
);
},
@ -202,9 +201,9 @@ export function getExecutors(app: {
skipLock: step.skipLock || _.get(step, ['options', 'skipLock']),
},
async () => {
await app.services.kill(step.current, { wait: true });
await serviceManager.kill(step.current, { wait: true });
app.callbacks.containerKilled(step.current.containerId);
const container = await app.services.start(step.target);
const container = await serviceManager.start(step.target);
app.callbacks.containerStarted(container.id);
},
);
@ -216,7 +215,7 @@ export function getExecutors(app: {
});
},
start: async (step) => {
const container = await app.services.start(step.target);
const container = await serviceManager.start(step.target);
app.callbacks.containerStarted(container.id);
},
updateCommit: async (step) => {
@ -230,7 +229,7 @@ export function getExecutors(app: {
skipLock: step.skipLock || _.get(step, ['options', 'skipLock']),
},
async () => {
await app.services.handover(step.current, step.target);
await serviceManager.handover(step.current, step.target);
},
);
},

185
src/compose/service-manager.ts
View File

@ -32,39 +32,42 @@ type ServiceManagerEventEmitter = StrictEventEmitter<
EventEmitter,
ServiceManagerEvents
>;
const events: ServiceManagerEventEmitter = new EventEmitter();
interface KillOpts {
removeContainer?: boolean;
wait?: boolean;
}
export class ServiceManager extends (EventEmitter as new () => ServiceManagerEventEmitter) {
export const on: typeof events['on'] = events.on.bind(events);
export const once: typeof events['once'] = events.once.bind(events);
export const removeListener: typeof events['removeListener'] = events.removeListener.bind(
events,
);
export const removeAllListeners: typeof events['removeAllListeners'] = events.removeAllListeners.bind(
events,
);
// Whether a container has died, indexed by ID
private containerHasDied: Dictionary<boolean> = {};
private listening = false;
const containerHasDied: Dictionary<boolean> = {};
let listening = false;
// Volatile state of containers, indexed by containerId (or random strings if
// we don't yet have an id)
private volatileState: Dictionary<Partial<Service>> = {};
const volatileState: Dictionary<Partial<Service>> = {};
public constructor() {
super();
}
public async getAll(
export async function getAll(
extraLabelFilters: string | string[] = [],
): Promise<Service[]> {
const filterLabels = ['supervised'].concat(extraLabelFilters);
const containers = await this.listWithBothLabels(filterLabels);
const containers = await listWithBothLabels(filterLabels);
const services = await Bluebird.map(containers, async (container) => {
try {
const serviceInspect = await docker
.getContainer(container.Id)
.inspect();
const serviceInspect = await docker.getContainer(container.Id).inspect();
const service = Service.fromDockerContainer(serviceInspect);
// We know that the containerId is set below, because `fromDockerContainer`
// always sets it
const vState = this.volatileState[service.containerId!];
const vState = volatileState[service.containerId!];
if (vState != null && vState.status != null) {
service.status = vState.status;
}
@ -80,11 +83,11 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return services.filter((s) => s != null) as Service[];
}
public async get(service: Service) {
export async function get(service: Service) {
// Get the container ids for special network handling
const containerIds = await this.getContainerIdMap(service.appId!);
const containerIds = await getContainerIdMap(service.appId!);
const services = (
await this.getAll(`service-id=${service.serviceId}`)
await getAll(`service-id=${service.serviceId}`)
).filter((currentService) =>
currentService.isEqualConfig(service, containerIds),
);
@ -99,9 +102,9 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return services[0];
}
public async getStatus() {
const services = await this.getAll();
const status = _.clone(this.volatileState);
export async function getStatus() {
const services = await getAll();
const status = _.clone(volatileState);
for (const service of services) {
if (service.containerId == null) {
@ -125,7 +128,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return _.values(status);
}
public async getByDockerContainerId(
export async function getByDockerContainerId(
containerId: string,
): Promise<Service | null> {
const container = await docker.getContainer(containerId).inspect();
@ -138,11 +141,11 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return Service.fromDockerContainer(container);
}
public async updateMetadata(
export async function updateMetadata(
service: Service,
metadata: { imageId: number; releaseId: number },
) {
const svc = await this.get(service);
const svc = await get(service);
if (svc.containerId == null) {
throw new InternalInconsistencyError(
`No containerId provided for service ${service.serviceName} in ServiceManager.updateMetadata. Service: ${service}`,
@ -154,46 +157,45 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
});
}
public async handover(current: Service, target: Service) {
export async function handover(current: Service, target: Service) {
// We set the running container to not restart so that in case of a poweroff
// it doesn't come back after boot.
await this.prepareForHandover(current);
await this.start(target);
await this.waitToKill(
await prepareForHandover(current);
await start(target);
await waitToKill(
current,
target.config.labels['io.balena.update.handover-timeout'],
);
await this.kill(current);
await kill(current);
}
public async killAllLegacy(): Promise<void> {
export async function killAllLegacy(): Promise<void> {
// Containers haven't been normalized (this is an updated supervisor)
// so we need to stop and remove them
const supervisorImageId = (
await docker.getImage(constants.supervisorImage).inspect()
).Id;
for (const container of await docker.listContainers({ all: true })) {
if (container.ImageID !== supervisorImageId) {
await this.killContainer(container.Id, {
await killContainer(container.Id, {
serviceName: 'legacy',
});
}
}
}
public kill(service: Service, opts: KillOpts = {}) {
export function kill(service: Service, opts: KillOpts = {}) {
if (service.containerId == null) {
throw new InternalInconsistencyError(
`Attempt to kill container without containerId! Service :${service}`,
);
}
return this.killContainer(service.containerId, service, opts);
return killContainer(service.containerId, service, opts);
}
public async remove(service: Service) {
export async function remove(service: Service) {
logger.logSystemEvent(LogTypes.removeDeadService, { service });
const existingService = await this.get(service);
const existingService = await get(service);
if (existingService.containerId == null) {
throw new InternalInconsistencyError(
@ -202,9 +204,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
}
try {
await docker
.getContainer(existingService.containerId)
.remove({ v: true });
await docker.getContainer(existingService.containerId).remove({ v: true });
} catch (e) {
if (!NotFoundError(e)) {
logger.logSystemEvent(LogTypes.removeDeadServiceError, {
@ -215,20 +215,20 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
}
}
}
public getAllByAppId(appId: number) {
return this.getAll(`app-id=${appId}`);
export function getAllByAppId(appId: number) {
return getAll(`app-id=${appId}`);
}
public async stopAllByAppId(appId: number) {
for (const app of await this.getAllByAppId(appId)) {
await this.kill(app, { removeContainer: false });
export async function stopAllByAppId(appId: number) {
for (const app of await getAllByAppId(appId)) {
await kill(app, { removeContainer: false });
}
}
public async create(service: Service) {
export async function create(service: Service) {
const mockContainerId = config.newUniqueKey();
try {
const existing = await this.get(service);
const existing = await get(service);
if (existing.containerId == null) {
throw new InternalInconsistencyError(
`No containerId provided for service ${service.serviceName} in ServiceManager.updateMetadata. Service: ${service}`,
@ -258,17 +258,15 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
'Attempt to start a service without an existing application ID',
);
}
const serviceContainerIds = await this.getContainerIdMap(service.appId);
const serviceContainerIds = await getContainerIdMap(service.appId);
const conf = service.toDockerContainer({
deviceName,
containerIds: serviceContainerIds,
});
const nets = serviceNetworksToDockerNetworks(
service.extraNetworksToJoin(),
);
const nets = serviceNetworksToDockerNetworks(service.extraNetworksToJoin());
logger.logSystemEvent(LogTypes.installService, { service });
this.reportNewStatus(mockContainerId, service, 'Installing');
reportNewStatus(mockContainerId, service, 'Installing');
const container = await docker.createContainer(conf);
service.containerId = container.id;
@ -285,22 +283,22 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
logger.logSystemEvent(LogTypes.installServiceSuccess, { service });
return container;
} finally {
this.reportChange(mockContainerId);
reportChange(mockContainerId);
}
}
public async start(service: Service) {
export async function start(service: Service) {
let alreadyStarted = false;
let containerId: string | null = null;
try {
const container = await this.create(service);
const container = await create(service);
containerId = container.id;
logger.logSystemEvent(LogTypes.startService, { service });
this.reportNewStatus(containerId, service, 'Starting');
reportNewStatus(containerId, service, 'Starting');
let remove = false;
let shouldRemove = false;
let err: Error | undefined;
try {
await container.start();
@ -309,10 +307,8 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
// definitely an int for comparison reasons
const maybeStatusCode = PermissiveNumber.decode(e.statusCode);
if (isLeft(maybeStatusCode)) {
remove = true;
err = new Error(
`Could not parse status code from docker error: ${e}`,
);
shouldRemove = true;
err = new Error(`Could not parse status code from docker error: ${e}`);
throw err;
}
const statusCode = maybeStatusCode.right;
@ -338,7 +334,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
throw e;
}
} finally {
if (remove) {
if (shouldRemove) {
// If starting the container fialed, we remove it so that it doesn't litter
await container.remove({ v: true }).catch(_.noop);
logger.logSystemEvent(LogTypes.startServiceError, {
@ -366,17 +362,17 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return container;
} finally {
if (containerId != null) {
this.reportChange(containerId);
reportChange(containerId);
}
}
}
public listenToEvents() {
if (this.listening) {
export function listenToEvents() {
if (listening) {
return;
}
this.listening = true;
listening = true;
const listen = async () => {
const stream = await docker.getEvents({
@ -394,22 +390,19 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
try {
let service: Service | null = null;
try {
service = await this.getByDockerContainerId(data.id);
service = await getByDockerContainerId(data.id);
} catch (e) {
if (!NotFoundError(e)) {
throw e;
}
}
if (service != null) {
this.emit('change');
events.emit('change');
if (status === 'die') {
logger.logSystemEvent(LogTypes.serviceExit, { service });
this.containerHasDied[data.id] = true;
} else if (
status === 'start' &&
this.containerHasDied[data.id]
) {
delete this.containerHasDied[data.id];
containerHasDied[data.id] = true;
} else if (status === 'start' && containerHasDied[data.id]) {
delete containerHasDied[data.id];
logger.logSystemEvent(LogTypes.serviceRestart, {
service,
});
@ -450,15 +443,15 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
log.error('Error listening to events:', e, e.stack);
})
.finally(() => {
this.listening = false;
setTimeout(() => this.listenToEvents(), 1000);
listening = false;
setTimeout(listenToEvents, 1000);
});
return;
}
public async attachToRunning() {
const services = await this.getAll();
export async function attachToRunning() {
const services = await getAll();
for (const service of services) {
if (service.status === 'Running') {
const serviceId = service.serviceId;
@ -482,31 +475,32 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
}
}
public async getContainerIdMap(appId: number): Promise<Dictionary<string>> {
return _(await this.getAllByAppId(appId))
export async function getContainerIdMap(
appId: number,
): Promise<Dictionary<string>> {
return _(await getAllByAppId(appId))
.keyBy('serviceName')
.mapValues('containerId')
.value() as Dictionary<string>;
}
private reportChange(containerId?: string, status?: Partial<Service>) {
function reportChange(containerId?: string, status?: Partial<Service>) {
if (containerId != null) {
if (status != null) {
this.volatileState[containerId] = {};
_.merge(this.volatileState[containerId], status);
} else if (this.volatileState[containerId] != null) {
delete this.volatileState[containerId];
volatileState[containerId] = { ...status };
} else if (volatileState[containerId] != null) {
delete volatileState[containerId];
}
}
this.emit('change');
events.emit('change');
}
private reportNewStatus(
function reportNewStatus(
containerId: string,
service: Partial<Service>,
status: string,
) {
this.reportChange(
reportChange(
containerId,
_.merge(
{ status },
@ -515,7 +509,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
);
}
private killContainer(
function killContainer(
containerId: string,
service: Partial<Service> = {},
{ removeContainer = true, wait = false }: KillOpts = {},
@ -528,7 +522,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return Bluebird.try(() => {
logger.logSystemEvent(LogTypes.stopService, { service });
if (service.imageId != null) {
this.reportNewStatus(containerId, service, 'Stopping');
reportNewStatus(containerId, service, 'Stopping');
}
const containerObj = docker.getContainer(containerId);
@ -566,7 +560,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
}
})
.tap(() => {
delete this.containerHasDied[containerId];
delete containerHasDied[containerId];
logger.logSystemEvent(LogTypes.stopServiceSuccess, { service });
})
.catch((e) => {
@ -577,7 +571,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
})
.finally(() => {
if (service.imageId != null) {
this.reportChange(containerId);
reportChange(containerId);
}
});
@ -588,7 +582,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
});
}
private async listWithBothLabels(
async function listWithBothLabels(
labelList: string[],
): Promise<Dockerode.ContainerInfo[]> {
const listWithPrefix = (prefix: string) =>
@ -607,8 +601,8 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
return _.unionBy(legacy, current, 'Id');
}
private async prepareForHandover(service: Service) {
const svc = await this.get(service);
async function prepareForHandover(service: Service) {
const svc = await get(service);
if (svc.containerId == null) {
throw new InternalInconsistencyError(
`No containerId provided for service ${service.serviceName} in ServiceManager.prepareForHandover. Service: ${service}`,
@ -621,7 +615,7 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
});
}
private waitToKill(service: Service, timeout: number | string) {
function waitToKill(service: Service, timeout: number | string) {
const pollInterval = 100;
timeout = checkInt(timeout, { positive: true }) || 60000;
const deadline = Date.now() + timeout;
@ -652,6 +646,3 @@ export class ServiceManager extends (EventEmitter as new () => ServiceManagerEve
log.success(`Handover complete for service ${service.serviceName}`);
});
}
}
export default ServiceManager;

7
src/device-api/v2.ts
View File

@ -10,6 +10,7 @@ import * as db from '../db';
import * as logger from '../logger';
import * as images from '../compose/images';
import * as volumeManager from '../compose/volume-manager';
import * as serviceManager from '../compose/service-manager';
import { spawnJournalctl } from '../lib/journald';
import {
appNotFoundMessage,
@ -153,7 +154,7 @@ export function createV2Api(router: Router, applications: ApplicationManager) {
// It's kinda hacky to access the services and db via the application manager
// maybe refactor this code
Bluebird.join(
applications.services.getStatus(),
serviceManager.getStatus(),
images.getStatus(),
db.models('app').select(['appId', 'commit', 'name']),
(
@ -359,7 +360,7 @@ export function createV2Api(router: Router, applications: ApplicationManager) {
});
router.get('/v2/containerId', async (req, res) => {
const services = await applications.services.getAll();
const services = await serviceManager.getAll();
if (req.query.serviceName != null || req.query.service != null) {
const serviceName = req.query.serviceName || req.query.service;
@ -393,7 +394,7 @@ export function createV2Api(router: Router, applications: ApplicationManager) {
const currentRelease = await config.get('currentCommit');
const pending = applications.deviceState.applyInProgress;
const containerStates = (await applications.services.getAll()).map((svc) =>
const containerStates = (await serviceManager.getAll()).map((svc) =>
_.pick(
svc,
'status',

3
src/lib/migration.ts
View File

@ -13,6 +13,7 @@ import { ApplicationManager } from '../application-manager';
import * as config from '../config';
import * as db from '../db';
import * as volumeManager from '../compose/volume-manager';
import * as serviceManager from '../compose/service-manager';
import DeviceState from '../device-state';
import * as constants from '../lib/constants';
import { BackupError, DatabaseParseError, NotFoundError } from '../lib/errors';
@ -244,7 +245,7 @@ export async function normaliseLegacyDatabase(
}
log.debug('Killing legacy containers');
await application.services.killAllLegacy();
await serviceManager.killAllLegacy();
log.debug('Migrating legacy app volumes');
const targetApps = await application.getTargetApps();

16
test/lib/mocked-device-api.ts
View File

@ -1,10 +1,9 @@
import { Router } from 'express';
import { fs } from 'mz';
import { stub } from 'sinon';
import { ApplicationManager } from '../../src/application-manager';
import * as networkManager from '../../src/compose/network-manager';
import { ServiceManager } from '../../src/compose/service-manager';
import * as serviceManager from '../../src/compose/service-manager';
import * as volumeManager from '../../src/compose/volume-manager';
import * as config from '../../src/config';
import * as db from '../../src/db';
@ -135,22 +134,23 @@ function buildRoutes(appManager: ApplicationManager): Router {
const originalNetGetAll = networkManager.getAllByAppId;
const originalVolGetAll = volumeManager.getAllByAppId;
const originalSvcGetStatus = serviceManager.getStatus;
function setupStubs() {
stub(ServiceManager.prototype, 'getStatus').resolves(STUBBED_VALUES.services);
// @ts-expect-error Assigning to a RO property
networkManager.getAllByAppId = () => Promise.resolve(STUBBED_VALUES.networks);
networkManager.getAllByAppId = async () => STUBBED_VALUES.networks;
// @ts-expect-error Assigning to a RO property
volumeManager.getAllByAppId = () => Promise.resolve(STUBBED_VALUES.volumes);
volumeManager.getAllByAppId = async () => STUBBED_VALUES.volumes;
// @ts-expect-error Assigning to a RO property
serviceManager.getStatus = async () => STUBBED_VALUES.services;
}
function restoreStubs() {
(ServiceManager.prototype as any).getStatus.restore();
// @ts-expect-error Assigning to a RO property
networkManager.getAllByAppId = originalNetGetAll;
// @ts-expect-error Assigning to a RO property
volumeManager.getAllByAppId = originalVolGetAll;
// @ts-expect-error Assigning to a RO property
serviceManager.getStatus = originalSvcGetStatus;
}
interface SupervisorAPIOpts {