Replace Daemon Communication Mechanism

packages/cli/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the Zowe CLI package will be documented in this file.
 
+## Recent Changes
+
+- **NEXT BREAKING** Enhancement: Use sockets and named pipes instead of ports for daemon communication for improved access control.
+
 ## `7.0.0-next.202202041954`
 
 - BugFix: Fixed daemon binaries missing from package and Keytar binaries not found at install time.

packages/cli/__tests__/daemon/__unit__/DaemonDecider.unit.test.ts

@@ -11,13 +11,19 @@
 
 jest.mock("net");
 jest.mock("@zowe/imperative");
+import * as fs from "fs";
 import * as net from "net";
+import * as os from "os";
+import * as path from "path";
 import Mock = jest.Mock;
 import { Imperative } from "@zowe/imperative";
 import { DaemonDecider } from "../../../src/daemon/DaemonDecider";
 jest.mock("../../../src/daemon//DaemonClient");
 
 describe("DaemonDecider tests", () => {
+    afterEach(() => {
+        delete process.env.ZOWE_DAEMON;
+    });
 
     it("should call normal parse method if no daemon keyword", () => {
 
@@ -64,7 +70,7 @@ describe("DaemonDecider tests", () => {
             // do nothing
         });
 
-        const listen = jest.fn((port, hostname, method) => {
+        const listen = jest.fn((socket, method) => {
             // do nothing
             method();
         });
@@ -109,7 +115,7 @@ describe("DaemonDecider tests", () => {
         expect(err.message).toBe("data");
     });
 
-    it("should set port based on env variable", () => {
+    it("should set socket based on env variable", () => {
 
         const log = jest.fn(() => {
             // do nothing
@@ -125,12 +131,195 @@ describe("DaemonDecider tests", () => {
 
         const daemonDecider = new DaemonDecider(["anything"]);
 
-        const testPort = "1234";
-
+        const testSocket = "/fake/pipe/path";
         (daemonDecider as any).mParms = ["one", "two", "--daemon"];
-        process.env.ZOWE_DAEMON = testPort;
+        process.env.ZOWE_DAEMON = testSocket;
         (daemonDecider as any).initialParse();
-        expect((daemonDecider as any).mPort).toBe(parseInt(testPort, 10));
+        expect((daemonDecider as any).mSocket).toBe(process.platform === "win32" ? "\\\\.\\pipe\\" + testSocket : testSocket);
+
+    });
+
+    (process.platform !== "win32" ? it : it.skip)("should try to delete an existing socket on *nix", () => {
+        const log = jest.fn(() => {
+            // do nothing
+        });
+
+        const on = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const listen = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const parse = jest.fn( (data, context) => {
+            expect(data).toBe(undefined);
+            expect(context).toBe(undefined);
+        });
+
+        (Imperative as any) = {
+            api: {
+                appLogger: {
+                    trace: log,
+                    debug: log,
+                    error: log
+                }
+            },
+            console: {
+                info: log
+            },
+            parse
+        };
+
+        const fn = net.createServer as Mock<typeof net.createServer>;
+        fn.mockImplementation((unusedclient, ...args: any[]) => {
+            return {on, listen};
+        });
+
+        const daemonDecider = new DaemonDecider(["node", "zowe", "--daemon"]);
+        const testSocket = "/fake/pipe/path";
+        process.env.ZOWE_DAEMON = testSocket;
+
+        const existsSyncSpy = jest.spyOn(fs, "existsSync");
+        existsSyncSpy.mockReturnValueOnce(true);
+
+        const unlinkSyncSpy = jest.spyOn(fs, "unlinkSync");
+        unlinkSyncSpy.mockReturnValueOnce(true);
+
+        daemonDecider.init();
+        daemonDecider.runOrUseDaemon();
+
+        expect(existsSyncSpy).toHaveBeenCalledTimes(1);
+        expect(unlinkSyncSpy).toHaveBeenCalledTimes(1);
+    });
+
+    (process.platform === "win32" ? it : it.skip)("should use the default socket location (win32)", () => {
+        const log = jest.fn(() => {
+            // do nothing
+        });
+
+        const on = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const listen = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const parse = jest.fn( (data, context) => {
+            expect(data).toBe(undefined);
+            expect(context).toBe(undefined);
+        });
+
+        (Imperative as any) = {
+            api: {
+                appLogger: {
+                    trace: log,
+                    debug: log,
+                    error: log
+                }
+            },
+            console: {
+                info: log
+            },
+            parse
+        };
+
+        const fn = net.createServer as Mock<typeof net.createServer>;
+        fn.mockImplementation((unusedclient, ...args: any[]) => {
+            return {on, listen};
+        });
+
+        const daemonDecider = new DaemonDecider(["node", "zowe", "--daemon"]);
+        daemonDecider.init();
+
+        expect((daemonDecider as any).mSocket).toEqual(`\\\\.\\pipe\\${os.userInfo().username}\\ZoweDaemon`);
+    });
+
+    (process.platform !== "win32" ? it : it.skip)("should use the default socket location (not win32)", () => {
+        const log = jest.fn(() => {
+            // do nothing
+        });
+
+        const on = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const listen = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const parse = jest.fn( (data, context) => {
+            expect(data).toBe(undefined);
+            expect(context).toBe(undefined);
+        });
+
+        (Imperative as any) = {
+            api: {
+                appLogger: {
+                    trace: log,
+                    debug: log,
+                    error: log
+                }
+            },
+            console: {
+                info: log
+            },
+            parse
+        };
+
+        const fn = net.createServer as Mock<typeof net.createServer>;
+        fn.mockImplementation((unusedclient, ...args: any[]) => {
+            return {on, listen};
+        });
+
+        const daemonDecider = new DaemonDecider(["node", "zowe", "--daemon"]);
+        daemonDecider.init();
+
+        expect((daemonDecider as any).mSocket).toEqual(path.join(os.homedir(), ".zowe-daemon.sock"));
+    });
+
+    it("should not start a daemon", () => {
+        const log = jest.fn(() => {
+            // do nothing
+        });
+
+        const on = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const listen = jest.fn((event, func) => {
+            // do nothing
+        });
+
+        const parse = jest.fn( (data, context) => {
+            expect(data).toBe(undefined);
+            expect(context).toBe(undefined);
+        });
+
+        (Imperative as any) = {
+            api: {
+                appLogger: {
+                    trace: log,
+                    debug: log,
+                    error: log
+                }
+            },
+            console: {
+                info: log
+            },
+            parse
+        };
+
+        const fn = net.createServer as Mock<typeof net.createServer>;
+        fn.mockImplementation((unusedclient, ...args: any[]) => {
+            return {on, listen};
+        });
+
+        const daemonDecider = new DaemonDecider(["node", "zowe", "--help"]);
+        daemonDecider.init();
 
+        expect((daemonDecider as any).mSocket).toBeUndefined();
+        expect((daemonDecider as any).startServer).toBeUndefined();
     });
 });

packages/cli/src/daemon/DaemonDecider.ts

@@ -9,9 +9,11 @@
 *
 */
 
-import { Imperative } from "@zowe/imperative";
+import * as fs from "fs";
 import * as net from "net";
-import { userInfo } from "os";
+import * as os from "os";
+import * as path from "path";
+import { Imperative } from "@zowe/imperative";
 import { DaemonClient } from "./DaemonClient";
 
 // TODO(Kelosky): handle prompting cases from login command
@@ -26,15 +28,6 @@ import { DaemonClient } from "./DaemonClient";
  * @class DaemonDecider
  */
 export class DaemonDecider {
-
-    /**
-     * Default port number
-     * @private
-     * @static
-     * @memberof DaemonDecider
-     */
-    private static readonly DEFAULT_PORT = 4000;
-
     /**
      * Undocumented paramter for launching in server mode
      * @private
@@ -52,12 +45,12 @@ export class DaemonDecider {
     private mServer: net.Server;
 
     /**
-     * Hold current port number for the server
+     * Hold current socket path for the server
      * @private
      * @type {number}
      * @memberof DaemonDecider
      */
-    private mPort: number;
+    private mSocket: string;
 
     /**
      * Hold current owner for the server
@@ -90,7 +83,7 @@ export class DaemonDecider {
 
         this.initialParse();
         if (this.startServer) {
-            this.mUser = userInfo().username;
+            this.mUser = os.userInfo().username;
             this.mServer = net.createServer((c) => {
                 new DaemonClient(c, this.mServer, this.mUser).run();
             });
@@ -107,9 +100,17 @@ export class DaemonDecider {
      */
     public runOrUseDaemon() {
         if (this.mServer) {
-            this.mServer.listen(this.mPort, "127.0.0.1", () => {
-                Imperative.api.appLogger.debug(`daemon server bound ${this.mPort}`);
-                Imperative.console.info(`server bound ${this.mPort}`);
+            if (process.platform !== "win32" && fs.existsSync(this.mSocket)) {
+                fs.unlinkSync(this.mSocket);
+            }
+
+            ["exit", "SIGINT", "SIGQUIT", "SIGTERM"].forEach((eventType: any) => {
+                process.on(eventType, this.close.bind(this, true));
+            });
+
+            this.mServer.listen(this.mSocket, () => {
+                Imperative.api.appLogger.debug(`daemon server bound ${this.mSocket}`);
+                Imperative.console.info(`server bound ${this.mSocket}`);
             });
         } else {
             Imperative.parse();
@@ -121,8 +122,11 @@ export class DaemonDecider {
      * @private
      * @memberof DaemonDecider
      */
-    private close() {
+    private close(shouldExit?: boolean) {
         Imperative.api.appLogger.debug(`server closed`);
+        if (shouldExit) {
+            process.exit();
+        }
     }
 
     /**
@@ -142,28 +146,29 @@ export class DaemonDecider {
      * @memberof DaemonDecider
      */
     private initialParse() {
-        const numOfParms = this.mParms.length - 2;
-        this.mPort = DaemonDecider.DEFAULT_PORT;
-
-        if (numOfParms > 0) {
-            const parm = this.mParms[2];
-
+        if (this.mParms.length > 2) {
             /**
-             * NOTE(Kelosky): For now, we use an undocumented paramter `--daemon`.  If found first,
+             * NOTE(Kelosky): For now, we use an undocumented parameter `--daemon`.  If found first,
              * we bypass `yargs` and begin running this as a persistent Processor.
              */
-            const portOffset = parm.indexOf(DaemonDecider.DAEMON_KEY);
+            const parm = this.mParms[2];
+            const daemonOffset = parm.indexOf(DaemonDecider.DAEMON_KEY);
 
-            if (portOffset > -1) {
+            if (daemonOffset > -1) {
                 this.startServer = true;
+
                 if (process.env.ZOWE_DAEMON) {
-                    try {
-                        this.mPort = parseInt(process.env.ZOWE_DAEMON, 10);
-                    } catch (err) {
-                        // do nothing
+                    this.mSocket = process.env.ZOWE_DAEMON;
+                    if (process.platform === "win32") {
+                        this.mSocket = `\\\\.\\pipe\\${this.mSocket}`;
                     }
+                } else if (process.platform !== "win32") {
+                    this.mSocket = path.join(os.homedir(), ".zowe-daemon.sock");
+                } else {
+                    this.mSocket = `\\\\.\\pipe\\${os.userInfo().username}\\ZoweDaemon`;
                 }
-                Imperative.api.appLogger.debug(`daemon server port ${this.mPort}`);
+
+                Imperative.api.appLogger.debug(`daemon server socket ${this.mSocket}`);
             }
         }
     }