Merge pull request #433 from dappnode/dynamic-dnp-timeout

Dynamic dnp timeout from manifest

Author: dapplion

packages/admin-ui/src/common/types.ts

@@ -327,6 +327,7 @@ export interface ContainerLabelTypes {
   "dappnode.dnp.chain": ChainDriver;
   "dappnode.dnp.isCore": boolean;
   "dappnode.dnp.isMain": boolean;
+  "dappnode.dnp.dockerTimeout": number;
   "dappnode.dnp.default.environment": string[];
   "dappnode.dnp.default.ports": string[];
   "dappnode.dnp.default.volumes": string[];
@@ -398,6 +399,7 @@ export interface PackageContainer {
   domainAlias?: string[];
   canBeFullnode?: boolean;
   isMain?: boolean;
+  dockerTimeout?: number;
   // Note: environment is only accessible doing a container inspect or reading the compose
   // envs?: PackageEnvs;
 }
@@ -809,6 +811,7 @@ export type InstallPackageDataPaths = Pick<
   | "manifestBackupPath"
   | "imagePath"
   | "isUpdate"
+  | "dockerTimeout"
 >;
 
 export interface InstallPackageData extends PackageRelease {
@@ -823,6 +826,7 @@ export interface InstallPackageData extends PackageRelease {
   compose: Compose;
   // User settings to be applied after running
   fileUploads?: { [serviceName: string]: { [containerPath: string]: string } };
+  dockerTimeout: number | undefined;
 }
 
 // Must be in-sync with SDK types
@@ -847,6 +851,9 @@ export interface PackageReleaseMetadata {
   restartCommand?: string;
   restartLaunchCommand?: string;
 
+  // "15min" | 3600
+  dockerTimeout?: string;
+
   requirements?: {
     minimumDappnodeVersion: string;
   };

packages/dappmanager/package.json

@@ -76,6 +76,7 @@
     "socket.io": "^2.3.0",
     "source-map-support": "^0.5.19",
     "stack-trace": "^0.0.10",
+    "timestring": "^6.0.0",
     "ts-loader": "^8.0.2",
     "tweetnacl": "^1.0.1",
     "tweetnacl-util": "^0.15.0",

packages/dappmanager/src/calls/packageRemove.ts

@@ -10,6 +10,7 @@ import * as getPath from "../utils/getPath";
 import shell from "../utils/shell";
 import { listPackage } from "../modules/docker/listContainers";
 import { logs } from "../logs";
+import { getDockerTimeoutMax } from "../modules/docker/utils";
 
 /**
  * Remove package data: docker down + disk files
@@ -19,16 +20,15 @@ import { logs } from "../logs";
  */
 export async function packageRemove({
   dnpName,
-  deleteVolumes = false,
-  timeout = 10
+  deleteVolumes = false
 }: {
   dnpName: string;
   deleteVolumes?: boolean;
-  timeout?: number;
 }): Promise<void> {
   if (!dnpName) throw Error("kwarg dnpName must be defined");
 
   const dnp = await listPackage({ dnpName });
+  const timeout = getDockerTimeoutMax(dnp.containers);
 
   if (dnp.isCore || dnp.dnpName === params.dappmanagerDnpName) {
     throw Error("Core packages cannot be cannot be removed");
@@ -49,7 +49,8 @@ export async function packageRemove({
     try {
       await dockerComposeDown(composePath, {
         volumes: deleteVolumes,
-        timeout
+        // Ignore timeout is user doesn't want to keep any data
+        timeout: deleteVolumes ? undefined : timeout
       });
       hasRemoved = true; // To mimic an early return
     } catch (e) {

packages/dappmanager/src/calls/packageRestart.ts

@@ -1,5 +1,7 @@
 import * as eventBus from "../eventBus";
+import { listPackage } from "../modules/docker/listContainers";
 import { restartPackage } from "../modules/docker/restartPackage";
+import { getDockerTimeoutMax } from "../modules/docker/utils";
 
 /**
  * Recreates a package containers
@@ -13,7 +15,14 @@ export async function packageRestart({
 }): Promise<void> {
   if (!dnpName) throw Error("kwarg dnpName must be defined");
 
-  await restartPackage({ dnpName, serviceNames, forceRecreate: true });
+  const dnp = await listPackage({ dnpName });
+  const timeout = getDockerTimeoutMax(dnp.containers);
+  await restartPackage({
+    dnpName,
+    serviceNames,
+    forceRecreate: true,
+    timeout
+  });
 
   // Emit packages update
   eventBus.requestPackages.emit();

packages/dappmanager/src/calls/packageRestartVolumes.ts

@@ -1,7 +1,11 @@
 import fs from "fs";
 import { uniq } from "lodash";
 import { listPackage } from "../modules/docker/listContainers";
-import { dockerComposeUp, dockerRm } from "../modules/docker/dockerCommands";
+import {
+  dockerComposeUp,
+  dockerRm,
+  dockerStop
+} from "../modules/docker/dockerCommands";
 import { removeNamedVolume } from "../modules/docker/removeNamedVolume";
 import * as eventBus from "../eventBus";
 import * as getPath from "../utils/getPath";
@@ -13,6 +17,7 @@ import {
 } from "../modules/docker/dockerApi";
 import { isVolumeOwner } from "../modules/docker/volumesData";
 import { InstalledPackageData } from "../types";
+import { getDockerTimeoutMax } from "../modules/docker/utils";
 
 /**
  * Removes a package volumes. The re-ups the package
@@ -33,6 +38,8 @@ export async function packageRestartVolumes({
   // Fetching all containers to not re-fetch below
   const volumes = await dockerVolumesList();
   const dnp = await listPackage({ dnpName });
+  const timeout = getDockerTimeoutMax(dnp.containers);
+
   if (dnp.dnpName === params.dappmanagerDnpName)
     throw Error("The dappmanager cannot be restarted");
 
@@ -54,14 +61,19 @@ export async function packageRestartVolumes({
 
   let err: Error | null = null;
   try {
-    if (containersToRemove.length > 0) await dockerRm(containersToRemove);
-    for (const volName of volumesToRemove) await removeNamedVolume(volName);
+    if (containersToRemove.length > 0) {
+      await dockerStop(containersToRemove, { time: timeout });
+      await dockerRm(containersToRemove);
+    }
+    for (const volName of volumesToRemove) {
+      await removeNamedVolume(volName);
+    }
   } catch (e) {
     err = e;
   }
 
   // In case of error: FIRST up the dnp, THEN throw the error
-  await dockerComposeUp(composePath);
+  await dockerComposeUp(composePath, { timeout });
   if (err) throw err;
 
   // Emit packages update

packages/dappmanager/src/calls/packageStartStop.ts

@@ -1,23 +1,23 @@
 import { listPackage } from "../modules/docker/listContainers";
 import { dockerStart, dockerStop } from "../modules/docker/dockerCommands";
 import * as eventBus from "../eventBus";
+import { getDockerTimeoutMax } from "../modules/docker/utils";
 
 /**
  * Stops or starts a package containers
  * @param timeout seconds to stop the package
  */
 export async function packageStartStop({
   dnpName,
-  serviceNames,
-  timeout = 10
+  serviceNames
 }: {
   dnpName: string;
   serviceNames?: string[];
-  timeout?: number;
 }): Promise<void> {
   if (!dnpName) throw Error("kwarg containerName must be defined");
 
   const dnp = await listPackage({ dnpName });
+  const timeout = getDockerTimeoutMax(dnp.containers);
 
   const targetContainers = dnp.containers.filter(
     c => !serviceNames || serviceNames.includes(c.serviceName)

packages/dappmanager/src/db/coreUpdate.ts

@@ -31,7 +31,8 @@ export const coreUpdatePackagesData = {
                 "manifestPath",
                 "manifestBackupPath",
                 "imagePath",
-                "isUpdate"
+                "isUpdate",
+                "dockerTimeout"
               ])
           )
         : packagesData

packages/dappmanager/src/modules/compose/labelsDb.ts

@@ -16,6 +16,8 @@ import { pick, omitBy, mapValues } from "lodash";
  */
 
 const parseString = (value: string | undefined): string | undefined => value;
+const parseNumber = (value: string | undefined): number | undefined =>
+  value === undefined ? undefined : parseInt(value);
 const parseBool = (value: string | undefined): boolean | undefined =>
   typeof value === "string" ? (value === "true" ? true : false) : undefined;
 const parseJsonSafe = <T>(value: string | undefined): T | undefined => {
@@ -26,6 +28,8 @@ const parseJsonSafe = <T>(value: string | undefined): T | undefined => {
 };
 
 const writeString = (data: string | undefined): string | undefined => data;
+const writeNumber = (num: number | undefined): string | undefined =>
+  num === undefined ? undefined : String(num);
 const writeBool = (data: boolean | undefined): string | undefined =>
   data === true ? "true" : data === false ? "false" : undefined;
 const writeJson = (data: object | string[]): string => JSON.stringify(data);
@@ -48,6 +52,7 @@ const labelParseFns: {
       : undefined,
   "dappnode.dnp.isCore": parseBool,
   "dappnode.dnp.isMain": parseBool,
+  "dappnode.dnp.dockerTimeout": parseNumber,
   "dappnode.dnp.default.environment": value => parseJsonSafe(value),
   "dappnode.dnp.default.ports": value => parseJsonSafe(value),
   "dappnode.dnp.default.volumes": value => parseJsonSafe(value)
@@ -68,6 +73,7 @@ const labelStringifyFns: {
   "dappnode.dnp.chain": writeString,
   "dappnode.dnp.isCore": writeBool,
   "dappnode.dnp.isMain": writeBool,
+  "dappnode.dnp.dockerTimeout": writeNumber,
   "dappnode.dnp.default.environment": writeJson,
   "dappnode.dnp.default.ports": writeJson,
   "dappnode.dnp.default.volumes": writeJson
@@ -128,6 +134,7 @@ export function readContainerLabels(
   chain: ChainDriver;
   isCore: boolean;
   isMain: boolean;
+  dockerTimeout: number;
   defaultEnvironment: string[];
   defaultPorts: string[];
   defaultVolumes: string[];
@@ -144,6 +151,7 @@ export function readContainerLabels(
     chain: labelValues["dappnode.dnp.chain"],
     isCore: labelValues["dappnode.dnp.isCore"],
     isMain: labelValues["dappnode.dnp.isMain"],
+    dockerTimeout: labelValues["dappnode.dnp.dockerTimeout"],
     defaultEnvironment: labelValues["dappnode.dnp.default.environment"],
     defaultPorts: labelValues["dappnode.dnp.default.ports"],
     defaultVolumes: labelValues["dappnode.dnp.default.volumes"]
@@ -159,7 +167,8 @@ export function writeMetadataToLabels({
   chain,
   origin,
   isCore,
-  isMain
+  isMain,
+  dockerTimeout
 }: {
   dnpName: string;
   version: string;
@@ -170,6 +179,7 @@ export function writeMetadataToLabels({
   origin?: string;
   isCore?: boolean;
   isMain?: boolean;
+  dockerTimeout?: number;
 }): ContainerLabelsRaw {
   return stringifyContainerLabels({
     "dappnode.dnp.dnpName": dnpName,
@@ -180,6 +190,7 @@ export function writeMetadataToLabels({
     "dappnode.dnp.origin": origin,
     "dappnode.dnp.chain": chain,
     "dappnode.dnp.isCore": isCore,
-    "dappnode.dnp.isMain": isMain
+    "dappnode.dnp.isMain": isMain,
+    "dappnode.dnp.dockerTimeout": dockerTimeout
   });
 }

packages/dappmanager/src/modules/docker/dockerCommands.ts

@@ -23,27 +23,36 @@ async function execDockerCompose(
   args: Args,
   kwargs?: Kwargs
 ): Promise<string> {
-  return shell(["docker-compose", "-f", dcPath, ...parseArgs(args, kwargs)]);
+  return shell([
+    "docker-compose",
+    "-f",
+    dcPath,
+    ...parseArgs(args, kwargs),
+    // Adding <&- to prevent interactive mode
+    "<&-"
+  ]);
 }
 
 export function dockerComposeUp(
   dcPath: string,
-  options?: {
+  options: {
     noStart?: boolean;
+    detach?: boolean;
     forceRecreate?: boolean;
+    timeout?: number;
     serviceNames?: string[];
     removeOrphans?: boolean;
-  }
+  } = {}
 ): Promise<string> {
-  const flags: string[] = [];
-  if (options?.noStart) flags.push("--no-start");
-  else flags.push("--detach");
-  if (options?.forceRecreate) flags.push("--force-recreate");
-  if (options?.removeOrphans) flags.push("--remove-orphans");
-  if (options?.serviceNames)
-    for (const serviceName of options.serviceNames) flags.push(serviceName);
-  // Adding <&- to prevent interactive mode
-  return execDockerCompose(dcPath, ["up", ...flags, "<&-"]);
+  // --detach is invalid with --no-start
+  if (options.noStart) options.detach = false;
+  return execDockerCompose(dcPath, ["up", ...(options.serviceNames || [])], {
+    noStart: options.noStart,
+    detach: options.detach ?? true,
+    forceRecreate: options.forceRecreate,
+    timeout: options.timeout,
+    removeOrphans: options.removeOrphans
+  });
 }
 
 /**
@@ -52,19 +61,19 @@ export function dockerComposeUp(
  */
 export function dockerComposeDown(
   dcPath: string,
-  { volumes, timeout }: { volumes?: boolean; timeout?: number } = {}
+  options: { volumes?: boolean; timeout?: number } = {}
 ): Promise<string> {
-  return execDockerCompose(dcPath, ["down"], { volumes, timeout });
+  return execDockerCompose(dcPath, ["down"], options);
 }
 
 /**
  * Removes all containers from a compose project
- * -f: Don't ask to confirm removal
- * -s: Stop the containers, if required, before removing
+ * --force   Don't ask to confirm removal
+ * --stop    Stop the containers, if required, before removing
  * @param dcPath
  */
 export function dockerComposeRm(dcPath: string): Promise<string> {
-  return execDockerCompose(dcPath, ["rm", "-sf"]);
+  return execDockerCompose(dcPath, ["rm"], { force: true, stop: true });
 }
 
 export function dockerComposeStart(dcPath: string): Promise<string> {
@@ -76,9 +85,9 @@ export function dockerComposeStart(dcPath: string): Promise<string> {
  */
 export function dockerComposeStop(
   dcPath: string,
-  { timeout }: { timeout?: number } = {}
+  options: { timeout?: number } = {}
 ): Promise<string> {
-  return execDockerCompose(dcPath, ["stop"], { timeout });
+  return execDockerCompose(dcPath, ["stop"], options);
 }
 
 export function dockerComposeConfig(dcPath: string): Promise<string> {
@@ -97,11 +106,11 @@ export function dockerStart(
 }
 
 export function dockerStop(
-  containerNames: string | string[],
-  { time }: { time?: number } = {}
+  containerNames: string[],
+  options: { time?: number } = {}
 ): Promise<string> {
   const ids = parseContainerIdArg(containerNames);
-  return execDocker(["stop", ...ids], { time });
+  return execDocker(["stop", ...ids], options);
 }
 
 export function dockerRm(

packages/dappmanager/src/modules/docker/listContainers.ts

@@ -130,6 +130,7 @@ function parseContainerInfo(container: ContainerInfo): PackageContainer {
     labels.defaultPorts && parsePortMappings(labels.defaultPorts);
   const defaultVolumes =
     labels.defaultVolumes && parseVolumeMappings(labels.defaultVolumes);
+  const dockerTimeout = labels.dockerTimeout;
 
   return {
     // Identification
@@ -190,7 +191,8 @@ function parseContainerInfo(container: ContainerInfo): PackageContainer {
     // Default settings on the original package version's docker-compose
     defaultEnvironment,
     defaultPorts,
-    defaultVolumes
+    defaultVolumes,
+    dockerTimeout
   };
 }