agent restart command

src/PolykeyAgent.ts

@@ -712,6 +712,25 @@ class PolykeyAgent {
     this.logger.info(`Destroyed ${this.constructor.name}`);
   }
 
+  public async restart({
+    password,
+    networkConfig = {},
+    fresh = false,
+  }: {
+    password: string;
+    networkConfig?: NetworkConfig;
+    fresh?: boolean;
+  }) {
+    this.logger.info(`Restarting ${this.constructor.name}`);
+    await this.stop();
+    await this.start({
+      password,
+      networkConfig,
+      fresh,
+    });
+    this.logger.info(`Restarted ${this.constructor.name}`);
+  }
+
   public setWorkerManager(workerManager: PolykeyWorkerManagerInterface) {
     this.db.setWorkerManager(workerManager);
     this.keyManager.setWorkerManager(workerManager);

src/bin/agent/CommandAgent.ts

@@ -1,5 +1,6 @@
 import CommandLock from './CommandLock';
 import CommandLockAll from './CommandLockAll';
+import CommandRestart from './CommandRestart';
 import CommandStart from './CommandStart';
 import CommandStatus from './CommandStatus';
 import CommandStop from './CommandStop';
@@ -13,6 +14,7 @@ class CommandAgent extends CommandPolykey {
     this.description('Agent Operations');
     this.addCommand(new CommandLock(...args));
     this.addCommand(new CommandLockAll(...args));
+    this.addCommand(new CommandRestart(...args));
     this.addCommand(new CommandStart(...args));
     this.addCommand(new CommandStatus(...args));
     this.addCommand(new CommandStop(...args));

src/bin/agent/CommandRestart.ts

@@ -0,0 +1,86 @@
+import type PolykeyClient from '../../PolykeyClient';
+import CommandPolykey from '../CommandPolykey';
+import * as binUtils from '../utils';
+import * as binOptions from '../utils/options';
+import * as binProcessors from '../utils/processors';
+import * as binErrors from '../errors';
+import config from '../../config';
+
+class CommandRestart extends CommandPolykey {
+  constructor(...args: ConstructorParameters<typeof CommandPolykey>) {
+    super(...args);
+    this.name('restart');
+    this.description('Restart the Polykey Agent');
+    this.addOption(binOptions.nodeId);
+    this.addOption(binOptions.clientHost);
+    this.addOption(binOptions.clientPort);
+    this.addOption(binOptions.ingressHost);
+    this.addOption(binOptions.ingressPort);
+    this.addOption(binOptions.fresh);
+    this.action(async (options) => {
+      const { default: PolykeyClient } = await import('../../PolykeyClient');
+      const agentPB = await import('../../proto/js/polykey/v1/agent/agent_pb');
+      const clientStatus = await binProcessors.processClientStatus(
+        options.nodePath,
+        options.nodeId,
+        options.clientHost,
+        options.clientPort,
+        this.fs,
+        this.logger.getChild(binProcessors.processClientOptions.name),
+      );
+      const statusInfo = clientStatus.statusInfo;
+      if (statusInfo?.status === 'DEAD') {
+        this.logger.info('Agent is already dead');
+        return;
+      } else if (statusInfo?.status === 'STOPPING') {
+        this.logger.info('Agent is already stopping');
+        return;
+      } else if (statusInfo?.status === 'STARTING') {
+        throw new binErrors.ErrorCLIStatusStarting();
+      }
+      const meta = await binProcessors.processAuthentication(
+        options.passwordFile,
+        this.fs,
+      );
+      const password = await binProcessors.processPassword(
+        options.passwordFile,
+        this.fs,
+      );
+      // Either the statusInfo is undefined or LIVE
+      // Either way, the connection parameters now exist
+      let pkClient: PolykeyClient;
+      this.exitHandlers.handlers.push(async () => {
+        if (pkClient != null) await pkClient.stop();
+      });
+      try {
+        pkClient = await PolykeyClient.createPolykeyClient({
+          nodePath: options.nodePath,
+          nodeId: clientStatus.nodeId!,
+          host: clientStatus.clientHost!,
+          port: clientStatus.clientPort!,
+          logger: this.logger.getChild(PolykeyClient.name),
+        });
+        const restartMessage = new agentPB.RestartMessage();
+        restartMessage.setPassword(password);
+        restartMessage.setClientHost(
+          options.clientHost ?? config.defaults.networkConfig.clientHost,
+        );
+        restartMessage.setClientPort(
+          options.clientPort ?? config.defaults.networkConfig.clientPort,
+        );
+        restartMessage.setIngressHost(options.ingressHost);
+        restartMessage.setIngressPort(options.ingressPort);
+        restartMessage.setFresh(options.fresh);
+        await binUtils.retryAuthentication(
+          (auth) => pkClient.grpcClient.agentRestart(restartMessage, auth),
+          meta,
+        );
+        this.logger.info('Restarting Agent');
+      } finally {
+        if (pkClient! != null) await pkClient.stop();
+      }
+    });
+  }
+}
+
+export default CommandRestart;

src/client/GRPCClientClient.ts

@@ -119,6 +119,14 @@ class GRPCClientClient extends GRPCClient<ClientServiceClient> {
     )(...args);
   }
 
+  @ready(new clientErrors.ErrorClientClientDestroyed())
+  public agentRestart(...args) {
+    return grpcUtils.promisifyUnaryCall<utilsPB.EmptyMessage>(
+      this.client,
+      this.client.agentRestart,
+    )(...args);
+  }
+
   @ready(new clientErrors.ErrorClientClientDestroyed())
   public vaultsList(
     ...args

src/client/service/agentRestart.ts

@@ -0,0 +1,47 @@
+import type { Host, Port } from '../../network/types';
+import type * as grpc from '@grpc/grpc-js';
+import type { Authenticate } from '../types';
+import type PolykeyAgent from '../../PolykeyAgent';
+import type * as agentPB from '../../proto/js/polykey/v1/agent/agent_pb';
+import * as grpcUtils from '../../grpc/utils';
+import * as utilsPB from '../../proto/js/polykey/v1/utils/utils_pb';
+
+function agentRestart({
+  authenticate,
+  pkAgent,
+}: {
+  authenticate: Authenticate;
+  pkAgent: PolykeyAgent;
+}) {
+  return async (
+    call: grpc.ServerUnaryCall<agentPB.RestartMessage, utilsPB.EmptyMessage>,
+    callback: grpc.sendUnaryData<utilsPB.EmptyMessage>,
+  ): Promise<void> => {
+    const response = new utilsPB.EmptyMessage();
+    try {
+      const metadata = await authenticate(call.metadata);
+      call.sendMetadata(metadata);
+      // Respond first to close the GRPC connection
+      callback(null, response);
+    } catch (err) {
+      callback(grpcUtils.fromError(err), null);
+      return;
+    }
+    const password = call.request.getPassword();
+    const networkConfig = {
+      clientHost: call.request.getClientHost() as Host,
+      clientPort: call.request.getClientPort() as Port,
+      ingressHost: call.request.getIngressHost() as Host,
+      ingressPort: call.request.getIngressPort() as Port,
+    };
+    const fresh = call.request.getFresh();
+    await pkAgent.restart({
+      password,
+      networkConfig,
+      fresh,
+    });
+    return;
+  };
+}
+
+export default agentRestart;

src/client/service/index.ts

@@ -19,6 +19,7 @@ import type { IClientServiceServer } from '../../proto/js/polykey/v1/client_serv
 import type { FileSystem } from '../../types';
 import Logger from '@matrixai/logger';
 import agentLockAll from './agentLockAll';
+import agentRestart from './agentRestart';
 import agentStatus from './agentStatus';
 import agentStop from './agentStop';
 import agentUnlock from './agentUnlock';
@@ -122,6 +123,7 @@ function createService({
   };
   const service: IClientServiceServer = {
     agentLockAll: agentLockAll(container),
+    agentRestart: agentRestart(container),
     agentStatus: agentStatus(container),
     agentStop: agentStop(container),
     agentUnlock: agentUnlock(container),

src/proto/js/polykey/v1/agent/agent_pb.d.ts

@@ -67,3 +67,38 @@ export namespace InfoMessage {
         rootCertChainPem: string,
     }
 }
+
+export class RestartMessage extends jspb.Message { 
+    getPassword(): string;
+    setPassword(value: string): RestartMessage;
+    getClientHost(): string;
+    setClientHost(value: string): RestartMessage;
+    getClientPort(): number;
+    setClientPort(value: number): RestartMessage;
+    getIngressHost(): string;
+    setIngressHost(value: string): RestartMessage;
+    getIngressPort(): number;
+    setIngressPort(value: number): RestartMessage;
+    getFresh(): boolean;
+    setFresh(value: boolean): RestartMessage;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RestartMessage.AsObject;
+    static toObject(includeInstance: boolean, msg: RestartMessage): RestartMessage.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RestartMessage, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RestartMessage;
+    static deserializeBinaryFromReader(message: RestartMessage, reader: jspb.BinaryReader): RestartMessage;
+}
+
+export namespace RestartMessage {
+    export type AsObject = {
+        password: string,
+        clientHost: string,
+        clientPort: number,
+        ingressHost: string,
+        ingressPort: number,
+        fresh: boolean,
+    }
+}