lupine.api 1.1.51 → 1.1.52

package/admin/admin-release.tsx

@@ -284,7 +284,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 +293,35 @@ 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 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 +350,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.52",
   "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/app/app-message.ts

@@ -2,6 +2,7 @@ import cluster from 'cluster';
 import { Logger, LogWriter, LogWriterMessageId } from '../lib';
 import { processDebugMessage } from './process-dev-requests';
 import { cleanupAndExit } from './cleanup-exit';
+import { restartApp } from './app-restart';
 
 export type AppMessageProps = {
   id: string;
@@ -78,15 +79,22 @@ 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') {
+      restartApp();
+      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}`);
   }
 };

package/src/app/app-restart.ts

@@ -0,0 +1,54 @@
+import cluster from 'cluster';
+import { spawn } from 'child_process';
+import { appStorage } from './app-shared-storage';
+import { AppMessageProps, processMessageFromWorker } from './app-message';
+
+export const _restartApp = {
+  isRestarting: false,
+};
+export const restartApp = async () => {
+  if (!cluster.isPrimary) {
+    console.warn(`restartApp: shouldn't come here`);
+    return;
+  }
+
+  await appStorage.save('', true);
+  console.log(`Old app ${process.pid} sends SIGTERM to all workors.`);
+  // const closeAll = () => {
+  //   _restartApp.isRestarting = true;
+
+  //   return Object.values(cluster.workers!).map(
+  //     (w) =>
+  //       new Promise((resolve) => {
+  //         console.log(`Sending SIGTERM to workor ${w!.id}.`);
+  //         w!.once('exit', resolve);
+  //         w!.kill('SIGTERM');
+  //       })
+  //   );
+  // };
+  // await Promise.all(closeAll());
+
+  console.log(`Old app ${process.pid} starts new app ${process.execPath}`, process.argv);
+  // spawn(process.execPath, process.argv.slice(1), {
+  //   stdio: 'inherit',
+  //   env: { ...process.env, RESTARTING: '1' },
+  // });
+
+  console.log(`Old app ${process.pid} exists.`);
+  // setTimeout(process.exit, 3000);
+  if (!process.send) {
+    console.log(`The primary process is not focked from loader, so cannot restart.`);
+  } else {
+    process.send({ id: 'debug', message: 'restartApp' });
+  }
+};
+
+// 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-start.ts

@@ -9,6 +9,7 @@ import { AppStartProps, InitStartProps, AppCacheGlobal, AppCacheKeys } from '../
 import { appStorage } from './app-shared-storage';
 import { HostToPath } from './host-to-path';
 import { cleanupAndExit } from './cleanup-exit';
+import { _restartApp, receiveMessageFromLoader } from './app-restart';
 
 // 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();
 
@@ -58,14 +65,20 @@ class AppStart {
       const numCPUs = props.debug ? 1 : require('os').cpus().length;
       console.log(`Master Process is trying to fork ${numCPUs} processes`);
 
+      receiveMessageFromLoader();
+
       for (let i = 0; i < numCPUs; i++) {
         let worker = cluster.fork();
         worker.on('message', processMessageFromWorker);
       }
 
       cluster.on('death', (worker: any) => {
-        console.log(`Worker ${worker.pid} died; starting a new one...`);
-        cluster.fork();
+        if (!_restartApp.isRestarting) {
+          console.log(`Worker ${worker.pid} died; starting a new one...`);
+          cluster.fork();
+        } else {
+          console.log(`Worker ${worker.pid} 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,21 @@ 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/process-dev-requests.ts

@@ -5,6 +5,7 @@ import { appLoader } from './app-loader';
 import { DebugService } from '../api/debug-service';
 import { AppCacheGlobal, AppCacheKeys, getAppCache, ServerRequest } from '../models';
 import { cleanupAndExit } from './cleanup-exit';
+import { restartApp } from './app-restart';
 const logger = new Logger('process-dev-requests');
 
 function deleteRequireCache(moduleName: string) {
@@ -42,10 +43,10 @@ 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(`[server] Received shutdown command.`);
+    await cleanupAndExit();
   }
 };
 
@@ -63,6 +64,18 @@ export async function processRefreshCache(req: ServerRequest) {
   }
 }
 
+export async function processRestartApp(req: ServerRequest) {
+  // if this is a child process, we need to notice parent process to broadcast to all clients to refresh
+  if (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 {
+    await restartApp();
+  }
+}
+
 // this is only for local development
 export async function processDevRequests(req: ServerRequest, res: ServerResponse, rootUrl?: string) {
   res.end();
@@ -71,15 +84,15 @@ export async function processDevRequests(req: ServerRequest, res: ServerResponse
     console.log(`[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(`[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);

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;
   }
 }