lupine.api 1.1.51 → 1.1.53

package/admin/admin-release.tsx

@@ -8,6 +8,7 @@ import {
   NotificationMessage,
   formatBytes,
   downloadStream,
+  ActionSheetSelectPromise,
 } from 'lupine.components';
 
 interface ReleaseListProps {
@@ -284,7 +285,7 @@ export const AdminReleasePage = () => {
       isLocal,
     });
     const dataResponse = await response.json;
-    console.log('AdminRelease', dataResponse);
+    console.log('refresh-cache', dataResponse);
     if (!dataResponse || dataResponse.status !== 'ok') {
       NotificationMessage.sendMessage(dataResponse.message || 'Failed to refresh cache', NotificationColor.Error);
       return;
@@ -293,6 +294,44 @@ export const AdminReleasePage = () => {
     NotificationMessage.sendMessage('Cache refreshed successfully', NotificationColor.Success);
   };
 
+  const onRestartAppLocal = async () => {
+    return onRestartApp(true);
+  };
+  const onRestartAppRemote = async () => {
+    return onRestartApp(false);
+  };
+  const onRestartApp = async (isLocal?: boolean) => {
+    const data = getDomData();
+    if (!isLocal) {
+      if (!data.targetUrl || !data.accessToken) {
+        NotificationMessage.sendMessage('Please fill in all fields', NotificationColor.Error);
+        return;
+      }
+    }
+
+    const index = await ActionSheetSelectPromise({
+      title: 'Restart App (users may get disconnected errors) ?',
+      options: ['OK'],
+      cancelButtonText: 'Cancel',
+    });
+    if (index !== 0) {
+      return;
+    }
+
+    const response = await getRenderPageProps().renderPageFunctions.fetchData('/api/admin/release/restart-app', {
+      ...data,
+      isLocal,
+    });
+    const dataResponse = await response.json;
+    console.log('restart-app', dataResponse);
+    if (!dataResponse || dataResponse.status !== 'ok') {
+      NotificationMessage.sendMessage(dataResponse.message || 'Failed to Restart App', NotificationColor.Error);
+      return;
+    }
+    domLog.value = <pre>{JSON.stringify(dataResponse, null, 2)}</pre>;
+    NotificationMessage.sendMessage('Restart App successfully', NotificationColor.Success);
+  };
+
   const ref: RefProps = {
     onLoad: async () => {
       const data = JSON.parse(localStorage.getItem('admin-release') || '{}');
@@ -321,9 +360,15 @@ export const AdminReleasePage = () => {
         <button onClick={onRefreshCacheRemote} class='button-base mr-m'>
           Refresh Cache (Remote)
         </button>
-        <button onClick={onRefreshCacheLocal} class='button-base'>
+        <button onClick={onRestartAppRemote} class='button-base mr-m color-red'>
+          Restart App (Remote)
+        </button>
+        <button onClick={onRefreshCacheLocal} class='button-base mr-m'>
           Refresh Cache (Local)
         </button>
+        <button onClick={onRestartAppLocal} class='button-base color-red'>
+          Restart App (Local)
+        </button>
       </div>
       {domUpdate.node}
       {domLog.node}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lupine.api",
-  "version": "1.1.51",
+  "version": "1.1.53",
   "license": "MIT",
   "author": "uuware.com",
   "homepage": "https://github.com/uuware/lupine.js",

package/src/admin-api/admin-auth.ts

@@ -69,14 +69,15 @@ export const devAdminAuth = async (req: ServerRequest, res: ServerResponse) => {
       ApiHelper.sendJson(req, res, response);
       return true;
     }
-    // if it's dev admin, then set app admin cookie as well
-    let addLoginResponse = {};
-    const appAdminHookSetCookie = adminApiHelper.getAppAdminHookSetCookie();
-    if (appAdminHookSetCookie) {
-      addLoginResponse = await appAdminHookSetCookie(req, res, devAdminSession.u);
-    }
+    // on set app cookie when login, not every time
+    // // if it's dev admin, then set app admin cookie as well
+    // let addLoginResponse = {};
+    // const appAdminHookSetCookie = adminApiHelper.getAppAdminHookSetCookie();
+    // if (appAdminHookSetCookie) {
+    //   addLoginResponse = await appAdminHookSetCookie(req, res, devAdminSession.u);
+    // }
     const response = {
-      ...addLoginResponse,
+      // ...addLoginResponse,
       status: 'ok',
       message: langHelper.getLang('shared:login_success'),
       devLogin: CryptoUtils.encrypt(JSON.stringify(devAdminSession), cryptoKey),
@@ -109,13 +110,13 @@ export const devAdminAuth = async (req: ServerRequest, res: ServerResponse) => {
       message: langHelper.getLang('shared:login_success'),
       devLogin: tokenCookie,
     };
-    req.locals.setCookie('_token', tokenCookie, {
-      expireDays: 360,
-      path: '/',
-      httpOnly: false,
-      secure: true,
-      sameSite: 'none',
-    });
+    // req.locals.setCookie('_token', tokenCookie, {
+    //   expireDays: 360,
+    //   path: '/',
+    //   httpOnly: false,
+    //   secure: true,
+    //   sameSite: 'none',
+    // });
     ApiHelper.sendJson(req, res, response);
     return true;
   }

package/src/admin-api/admin-release.ts

@@ -11,6 +11,7 @@ import {
   adminApiHelper,
   processRefreshCache,
   apiStorage,
+  processRestartApp,
 } from 'lupine.api';
 import path from 'path';
 import { needDevAdminSession } from './admin-auth';
@@ -36,11 +37,13 @@ export class AdminRelease implements IApiBase {
     this.router.use('/view-log', needDevAdminSession, this.viewLog.bind(this));
     // called online or by clients
     this.router.use('/refresh-cache', needDevAdminSession, this.refreshCache.bind(this));
+    this.router.use('/restart-app', needDevAdminSession, this.restartApp.bind(this));
 
     // ...ByClient will verify credentials from post, so it doesn't need AdminSession
     this.router.use('/byClientCheck', this.byClientCheck.bind(this));
     this.router.use('/byClientUpdate', this.byClientUpdate.bind(this));
     this.router.use('/byClientRefreshCache', this.byClientRefreshCache.bind(this));
+    this.router.use('/byClientRestartApp', this.byClientRestartApp.bind(this));
     this.router.use('/byClientViewLog', this.byClientViewLog.bind(this));
   }
 
@@ -126,6 +129,47 @@ export class AdminRelease implements IApiBase {
     return true;
   }
 
+  async restartApp(req: ServerRequest, res: ServerResponse) {
+    // check whether it's from online admin
+    const json = await adminApiHelper.getDevAdminFromCookie(req, res, false);
+    const jsonData = req.locals.json();
+    if (json && jsonData && !Array.isArray(jsonData) && jsonData.isLocal) {
+      await processRestartApp(req);
+      const response = {
+        status: 'ok',
+        message: 'Restart app successfully.',
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    let targetUrl = data.targetUrl as string;
+    if (targetUrl.endsWith('/')) {
+      targetUrl = targetUrl.slice(0, -1);
+    }
+    const remoteData = await fetch(targetUrl + '/api/admin/release/byClientRestartApp', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+    const resultText = await remoteData.text();
+    let remoteResult: any;
+    try {
+      remoteResult = JSON.parse(resultText);
+    } catch (e: any) {
+      remoteResult = { status: 'error', message: resultText };
+    }
+    const response = {
+      status: 'ok',
+      message: 'check.',
+      ...remoteResult,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
   public async chkData(data: any, req: ServerRequest, res: ServerResponse, chkCredential: boolean) {
     // add access token
     if (!data || Array.isArray(data) || typeof data !== 'object' || !data.accessToken || !data.targetUrl) {
@@ -569,4 +613,18 @@ export class AdminRelease implements IApiBase {
     ApiHelper.sendJson(req, res, response);
     return true;
   }
+
+  async byClientRestartApp(req: ServerRequest, res: ServerResponse) {
+    const jsonData = req.locals.json();
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    await processRestartApp(req);
+    const response = {
+      status: 'ok',
+      message: 'Restart app successfully.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
 }

package/src/api/debug-service.ts

@@ -48,7 +48,7 @@ export class DebugService {
 
   // broadcast to all frontend clients
   public static broadcastRefresh() {
-    console.log(`broadcast refresh request to clients.`);
+    console.log(`${process.pid} - broadcast refresh request to clients.`);
     this.clientRefreshFlag = Date.now();
     const msg = { message: 'Refresh', flag: this.clientRefreshFlag };
     this.miniWebSocket.broadcast(JSON.stringify(msg));

package/src/api/static-server.ts

@@ -71,7 +71,7 @@ export class StaticServer {
 
       // if fullPath doesn't exist, it will throw ENOENT error
       const realPath = await fs.promises.realpath(fullPath);
-      console.log(`request: ${realPath}`);
+      console.log(`${process.pid} - request: ${realPath}`);
       // for security reason, the requested file should be inside of wwwRoot
       if (realPath.substring(0, hostPath.webPath.length) !== hostPath.webPath) {
         this.logger.warn(`ACCESS DENIED: ${urlSplit[0]}`);

package/src/app/app-loader.ts

@@ -51,7 +51,7 @@ class AppLoader {
     const apiPath = path.join(process.cwd(), 'dist/server_root', appConfig.appName + '_api/index.js');
     for (const path in require.cache) {
       if (path.endsWith('.js') && path.indexOf(apiPath) <= 0) {
-        console.log(`clear cache: ${path}`);
+        console.log(`${process.pid} - clear cache: ${path}`);
         delete require.cache[path];
       }
     }

package/src/app/app-message.ts

@@ -1,6 +1,6 @@
 import cluster from 'cluster';
 import { Logger, LogWriter, LogWriterMessageId } from '../lib';
-import { processDebugMessage } from './process-dev-requests';
+import { processDebugMessage, snedRestartAppMsgToLoader } from './process-dev-requests';
 import { cleanupAndExit } from './cleanup-exit';
 
 export type AppMessageProps = {
@@ -78,15 +78,32 @@ export const processMessageFromWorker = (msgObject: AppMessageProps) => {
     logger.debug(
       `Message from worker ${cluster.worker?.id}, message: ${msgObject.message}, appName: ${msgObject.appName}`
     );
-    broadcast(msgObject);
-    // if it's suspend, the primary process will exit
-    if (msgObject.message === 'suspend') {
-      setTimeout(() => {
-        console.log(`[server primary] Received suspend command.`, cluster.workers);
-        cleanupAndExit();
+    if (msgObject.message === 'restartApp') {
+      snedRestartAppMsgToLoader();
+      return;
+    } else if (msgObject.message === 'refresh') {
+      broadcast(msgObject);
+    } else if (msgObject.message === 'shutdown') {
+      broadcast(msgObject);
+      // if it's shutdown, the primary process will exit
+      setTimeout(async () => {
+        console.log(`[server primary] Received shutdown command.`, cluster.workers);
+        await cleanupAndExit();
       }, 100);
+    } else {
+      logger.warn(`Unknown message: ${msgObject.id}`);
     }
   } else {
-    logger.warn(`Unknown message: ${msgObject.id}`);
+    logger.warn(`Unknown message id: ${msgObject.id}`);
   }
 };
+
+// this is primary, and receive messages from loader
+export const receiveMessageFromLoader = () => {
+  process.on('message', async (msg: AppMessageProps) => {
+    if (msg?.id === 'debug' && msg?.message === 'shutdown') {
+      console.log(`App ${process.pid}: received shutdown message from loader.`);
+      processMessageFromWorker(msg);
+    }
+  });
+};

package/src/app/app-shared-storage.ts

@@ -166,7 +166,7 @@ export class AppSharedStorage implements IAppSharedStorage {
   // this can be called in primary or worker
   get(appName: string, key: string): Promise<string> {
     return new Promise((resolve, reject) => {
-      console.log(`AppStorage get value start in ${process.pid}, for key: ${key}`);
+      console.log(`${process.pid} - AppStorage get value for key: ${key}`);
 
       if (!cluster.isPrimary) {
         AppSharedStorageWorker.get(appName, key, resolve, reject);
@@ -196,7 +196,7 @@ export class AppSharedStorage implements IAppSharedStorage {
   }
   getWithPrefix(appName: string, prefixKey: string): Promise<SimpleStorageDataProps> {
     return new Promise((resolve, reject) => {
-      console.log(`AppStorage getWithPrefix start in ${process.pid}, for prefixKey: ${prefixKey}`);
+      console.log(`${process.pid} - AppStorage getWithPrefix for prefixKey: ${prefixKey}`);
 
       if (!cluster.isPrimary) {
         AppSharedStorageWorker.getWithPrefix(appName, prefixKey, resolve, reject);
@@ -238,7 +238,7 @@ class AppSharedStorageWorker {
     }
 
     if (msgObject.action === 'get') {
-      console.log(`AppStorage get value end in process: ${process.pid}, for key: ${msgObject.key}`);
+      console.log(`${process.pid} - AppStorage get value end for key: ${msgObject.key}`);
 
       const value = msgObject.value;
       // how to pass the value to the caller
@@ -250,7 +250,7 @@ class AppSharedStorageWorker {
         throw new Error(`Unknown uniqueKey: ${msgObject.uniqueKey}`);
       }
     } else if (msgObject.action === 'getWithPrefix') {
-      console.log(`AppStorage get value end in process: ${process.pid}, for key: ${msgObject.key}`);
+      console.log(`${process.pid} - AppStorage get value end for key: ${msgObject.key}`);
       const value = JSON.parse(msgObject.value);
       // how to pass the value to the caller
       const map = this.handleMap[msgObject.uniqueKey];

package/src/app/app-start.ts

@@ -8,7 +8,8 @@ import { appCache } from './app-cache';
 import { AppStartProps, InitStartProps, AppCacheGlobal, AppCacheKeys } from '../models';
 import { appStorage } from './app-shared-storage';
 import { HostToPath } from './host-to-path';
-import { cleanupAndExit } from './cleanup-exit';
+import { _exitApp, cleanupAndExit } from './cleanup-exit';
+import { receiveMessageFromLoader } from './app-message';
 
 // Don't use logger before set process message
 class AppStart {
@@ -16,10 +17,16 @@ class AppStart {
   webServer: WebServer | undefined;
 
   getWorkerId() {
-    return cluster.worker ? cluster.worker.id : 0;
+    return cluster.worker ? cluster.worker.id : -1;
   }
 
   async start(props: AppStartProps, webServer?: WebServer) {
+    // if it's started from spawn, wait for old master to clear ports
+    if (cluster.isPrimary && process.env.RESTARTING === '1') {
+      console.log(`New app ${process.pid} RESTARTING.`);
+      await new Promise((r) => setTimeout(r, 100));
+    }
+
     this.debug = props.debug;
     this.bindProcess();
 
@@ -34,9 +41,9 @@ class AppStart {
 
     // call the Logger after initLog
     console.log(
-      `${cluster.isPrimary ? 'Primary Process' : 'Worker Process'}, Starting Server - process id ${
-        process.pid
-      }, path: ${process.cwd()}`
+      `${process.pid} - ${
+        cluster.isPrimary ? 'Primary Process' : 'Worker Process'
+      }, Starting Server, path: ${process.cwd()}`
     );
 
     // when it's cluster.isPrimary or props.debug, initialize the shared storage first
@@ -47,7 +54,7 @@ class AppStart {
     }
 
     if (!cluster.isPrimary) {
-      console.log(`Worker id ${this.getWorkerId()}`);
+      console.log(`${process.pid} - Worker id ${this.getWorkerId()}`);
 
       process.on('message', processMessageFromPrimary);
 
@@ -56,7 +63,9 @@ class AppStart {
       this.initServer(props.serverConfig);
     } else if (cluster.isPrimary) {
       const numCPUs = props.debug ? 1 : require('os').cpus().length;
-      console.log(`Master Process is trying to fork ${numCPUs} processes`);
+      console.log(`${process.pid} - Primary Process is trying to fork ${numCPUs} processes`);
+
+      receiveMessageFromLoader();
 
       for (let i = 0; i < numCPUs; i++) {
         let worker = cluster.fork();
@@ -64,8 +73,12 @@ class AppStart {
       }
 
       cluster.on('death', (worker: any) => {
-        console.log(`Worker ${worker.pid} died; starting a new one...`);
-        cluster.fork();
+        if (!_exitApp.isExiting) {
+          console.log(`${worker.pid} - Worker died; starting a new one...`);
+          cluster.fork();
+        } else {
+          console.log(`${worker.pid} - Worker exited during restart`);
+        }
       });
     }
   }
@@ -82,7 +95,7 @@ class AppStart {
 
     // do something when app is closing
     process.on('beforeExit', async () => {
-      cleanupAndExit();
+      await cleanupAndExit();
     });
     process.on('exit', (ret) => {
       console.log(`${process.pid} - Process on exit, code: ${ret}`);
@@ -103,14 +116,20 @@ class AppStart {
     const sslKeyPath = config.sslKeyPath || '';
     const sslCrtPath = config.sslCrtPath || '';
 
-    console.log(`Starting Web Server, httpPort: ${httpPort}, httpsPort: ${httpsPort}`);
+    console.log(`${process.pid} - Starting Web Server, httpPort: ${httpPort}, httpsPort: ${httpsPort}`);
     // for dev to refresh the FE or stop the server
     if (this.debug) {
       WebProcessor.enableDebug('/debug', processDevRequests);
     }
 
-    httpPort && this.webServer!.startHttp(httpPort, bindIp);
-    httpsPort && this.webServer!.startHttps(httpsPort, bindIp, sslKeyPath, sslCrtPath);
+    const httpServer = httpPort && this.webServer!.startHttp(httpPort, bindIp);
+    const heepsServer = httpsPort && this.webServer!.startHttps(httpsPort, bindIp, sslKeyPath, sslCrtPath);
+
+    process.on('SIGTERM', () => {
+      console.log(`${process.pid} - Worker closing servers...`);
+      httpServer && httpServer.close();
+      heepsServer && heepsServer.close();
+    });
   }
 }
 

package/src/app/cleanup-exit.ts

@@ -1,6 +1,9 @@
 import cluster from 'cluster';
 import { appStorage } from './app-shared-storage';
 
+export const _exitApp = {
+  isExiting: false,
+};
 export const cleanupAndExit = async () => {
   console.log(`${process.pid} - Process on SIGINT, exit.`);
   // save shared storage first
@@ -8,5 +11,6 @@ export const cleanupAndExit = async () => {
     // save only happens once
     await appStorage.save('', true);
   }
+  _exitApp.isExiting = true;
   process.exit(0);
 };

package/src/app/process-dev-requests.ts

@@ -1,3 +1,4 @@
+import cluster from 'cluster';
 import { Logger } from '../lib/logger';
 import { ServerResponse } from 'http';
 import { AddressInfo } from 'net';
@@ -42,20 +43,20 @@ export const processDebugMessage = async (msgObject: any) => {
     // this only works in debug mode (no clusters)
     DebugService.broadcastRefresh();
   }
-  if (msgObject.id === 'debug' && msgObject.message === 'suspend') {
-    // Only when it's debug mode, it can go here, otherwise suspend should be processed in processMessageFromWorker
-    console.log(`[server] Received suspend command.`);
-    cleanupAndExit();
+  if (msgObject.id === 'debug' && msgObject.message === 'shutdown') {
+    // Only when it's debug mode, it can go here, otherwise shutdown should be processed in processMessageFromWorker
+    console.log(`${process.pid} - [server] Received shutdown command.`);
+    await cleanupAndExit();
   }
 };
 
 export async function processRefreshCache(req: ServerRequest) {
-  // if this is a child process, we need to notice parent process to broadcast to all clients to refresh
-  if (process.send) {
+  // if this is a child process, we need to notice parent process to broadcast to all clients
+  if (!cluster.isPrimary && process.send) {
     const appName = req.locals.query.get('appName');
     process.send({ id: 'debug', message: 'refresh', appName });
   }
-  // if it's debug mode (only one process)
+  // in case if it's only one process (primary process)
   else {
     // if (getAppCache().get(APP_GLOBAL, AppCacheKeys.API_DEBUG) === true)
     const appName = req.locals.query.get('appName');
@@ -63,28 +64,56 @@ export async function processRefreshCache(req: ServerRequest) {
   }
 }
 
-// this is only for local development
+export async function processRestartApp(req: ServerRequest) {
+  // if this is a child process, we need to notice parent process to broadcast to all clients
+  if (!cluster.isPrimary && process.send) {
+    // send message to Primary to handle it
+    process.send({ id: 'debug', message: 'restartApp' });
+  }
+  // in case if it's only one process (primary process)
+  else {
+    snedRestartAppMsgToLoader();
+  }
+}
+
+// this is called from a request in debug mode
 export async function processDevRequests(req: ServerRequest, res: ServerResponse, rootUrl?: string) {
   res.end();
   const address = req.socket.address() as AddressInfo;
   if (address.address !== '127.0.0.1') {
-    console.log(`[server] Ignore request from: `, req.url, address.address);
+    console.log(`${process.pid} - [server] Ignore request from: `, req.url, address.address);
     return true;
   }
-  if (req.url === '/debug/suspend') {
-    console.log(`[server] Received suspend command.`);
+  if (req.url === '/debug/shutdown') {
+    console.log(`${process.pid} - [server] Received shutdown command.`);
     if (process.send) {
       // send to parent process to kill all
-      process.send({ id: 'debug', message: 'suspend' });
+      process.send({ id: 'debug', message: 'shutdown' });
     }
     // if it's debug mode (only one process)
     else if (getAppCache().get(AppCacheGlobal, AppCacheKeys.APP_DEBUG) === true) {
-      await processDebugMessage({ id: 'debug', message: 'suspend' });
+      await processDebugMessage({ id: 'debug', message: 'shutdown' });
     }
   } else if (req.url === '/debug/refresh') {
     await processRefreshCache(req);
   }
-  if (req.url === '/debug/client') {
-  }
+  // else if (req.url === '/debug/client') {
+  // }
   return true;
 }
+
+// this is called from a request and passes the restartApp message to loader
+export const snedRestartAppMsgToLoader = async () => {
+  if (!cluster.isPrimary) {
+    console.warn(`restartApp: shouldn't come here`);
+    return;
+  }
+
+  if (!process.send) {
+    console.log(`${process.pid} - The primary process is not focked from loader, so cannot restart.`);
+  } else {
+    console.log(`${process.pid} - Old app sends restartApp to loader (${process.execPath})`);
+
+    process.send({ id: 'debug', message: 'restartApp' });
+  }
+};

package/src/app/web-server.ts

@@ -8,6 +8,7 @@ import { IncomingMessage, ServerResponse } from 'http';
 import { Duplex } from 'stream';
 import { WebProcessor } from './web-processor';
 import { DebugService } from '../api/debug-service';
+import cluster from 'cluster';
 const logger = new Logger('web-server');
 
 export class WebServer {
@@ -47,7 +48,7 @@ export class WebServer {
     httpServer.on('upgrade', this.handleUpgrade.bind(this));
 
     httpServer.listen(httpPort, bindIp, () => {
-      logger.info(`Http Server is started: http://localhost:${httpPort}`);
+      logger.info(`Http Server ${cluster.worker ? cluster.worker.id : -1} is started: http://localhost:${httpPort}`);
     });
     httpServer.on('error', (error: any) => {
       logger.error('Error occurred on http server', error);
@@ -88,11 +89,12 @@ export class WebServer {
       httpsServer.setTimeout(timeout);
     }
     httpsServer.listen(httpsPort, bindIp, () => {
-      logger.info(`Https Server is started: https://localhost:${httpsPort}`);
+      logger.info(`Https Server ${cluster.worker ? cluster.worker.id : -1} is started: https://localhost:${httpsPort}`);
     });
     httpsServer.on('error', (error: any) => {
       logger.error('Error occurred on https server', error);
     });
+
     return httpsServer;
   }
 }