refactor ConfigPubsub -> S2sMessaging

config/env.dev.js

@@ -11,7 +11,7 @@ module.exports = {
   HACKMD_URI: 'http://localhost:3010',
   HACKMD_URI_FOR_SERVER: 'http://hackmd:3000',
   // DRAWIO_URI: 'http://localhost:8080/?offline=1&https=0',
-  // CONFIG_PUBSUB_SERVER_TYPE: 'nchan',
+  // S2SMSG_PUBSUB_SERVER_TYPE: 'nchan',
   PLUGIN_NAMES_TOBE_LOADED: [
     // 'growi-plugin-lsx',
     // 'growi-plugin-pukiwiki-like-linker',

config/logger/config.dev.js

@@ -16,7 +16,7 @@ module.exports = {
   'growi:routes:login-passport': 'debug',
   'growi:middleware:safe-redirect': 'debug',
   'growi:service:PassportService': 'debug',
-  'growi:service:config-pubsub:*': 'debug',
+  'growi:service:s2s-messaging:*': 'debug',
   // 'growi:service:ConfigManager': 'debug',
   // 'growi:service:mail': 'debug',
   'growi:lib:search': 'debug',

src/server/crowi/express-init.js

@@ -20,7 +20,7 @@ module.exports = function(crowi, app) {
 
   const registerSafeRedirect = require('../middlewares/safe-redirect')();
   const injectCurrentuserToLocalvars = require('../middlewares/inject-currentuser-to-localvars')();
-  const autoReconnectToConfigPubsub = require('../middlewares/auto-reconnect-to-config-pubsub')(crowi);
+  const autoReconnectToS2sMsgServer = require('../middlewares/auto-reconnect-to-s2s-msg-server')(crowi);
   const { listLocaleIds } = require('@commons/util/locale-utils');
 
   const avoidSessionRoutes = require('../routes/avoid-session-routes');
@@ -118,7 +118,7 @@ module.exports = function(crowi, app) {
 
   app.use(registerSafeRedirect);
   app.use(injectCurrentuserToLocalvars);
-  app.use(autoReconnectToConfigPubsub);
+  app.use(autoReconnectToS2sMsgServer);
 
   const middlewares = require('../util/middlewares')(crowi, app);
   app.use(middlewares.swigFilters(swig));

src/server/crowi/index.js

@@ -37,6 +37,7 @@ function Crowi(rootdir) {
 
   this.config = {};
   this.configManager = null;
+  this.s2sMessagingService = null;
   this.mailService = null;
   this.passportService = null;
   this.globalNotificationService = null;
@@ -80,6 +81,9 @@ Crowi.prototype.init = async function() {
   await this.setupModels();
   await this.setupSessionConfig();
   await this.setupConfigManager();
+
+  // setup messaging services
+  await this.setupS2sMessagingService();
   await this.setupSocketIoService();
 
   // customizeService depends on AppService and XssService
@@ -254,15 +258,18 @@ Crowi.prototype.setupSessionConfig = async function() {
 Crowi.prototype.setupConfigManager = async function() {
   const ConfigManager = require('../service/config-manager');
   this.configManager = new ConfigManager(this.model('Config'));
-  await this.configManager.loadConfigs();
+  return this.configManager.loadConfigs();
+};
 
-  // setup pubsub
-  this.configPubsub = require('../service/config-pubsub')(this);
-  if (this.configPubsub != null) {
-    this.configPubsub.subscribe();
-    this.configManager.setPubsub(this.configPubsub);
+Crowi.prototype.setupS2sMessagingService = async function() {
+  const s2sMessagingService = require('../service/s2s-messaging')(this);
+  if (s2sMessagingService != null) {
+    s2sMessagingService.subscribe();
+    this.configManager.setPubsub(s2sMessagingService);
     // add as a message handler
-    this.configPubsub.addMessageHandler(this.configManager);
+    s2sMessagingService.addMessageHandler(this.configManager);
+
+    this.s2sMessagingService = s2sMessagingService;
   }
 };
 
@@ -335,8 +342,8 @@ Crowi.prototype.setupPassport = async function() {
   }
 
   // add as a message handler
-  if (this.configPubsub != null) {
-    this.configPubsub.addMessageHandler(this.passportService);
+  if (this.s2sMessagingService != null) {
+    this.s2sMessagingService.addMessageHandler(this.passportService);
   }
 
   return Promise.resolve();
@@ -352,8 +359,8 @@ Crowi.prototype.setupMailer = async function() {
   this.mailService = new MailService(this);
 
   // add as a message handler
-  if (this.configPubsub != null) {
-    this.configPubsub.addMessageHandler(this.mailService);
+  if (this.s2sMessagingService != null) {
+    this.s2sMessagingService.addMessageHandler(this.mailService);
   }
 };
 
@@ -512,8 +519,8 @@ Crowi.prototype.setUpCustomize = async function() {
     this.customizeService.initCustomTitle();
 
     // add as a message handler
-    if (this.configPubsub != null) {
-      this.configPubsub.addMessageHandler(this.customizeService);
+    if (this.s2sMessagingService != null) {
+      this.s2sMessagingService.addMessageHandler(this.customizeService);
     }
   }
 };
@@ -528,8 +535,8 @@ Crowi.prototype.setUpApp = async function() {
 
     // add as a message handler
     const isInstalled = this.configManager.getConfig('crowi', 'app:installed');
-    if (this.configPubsub != null && !isInstalled) {
-      this.configPubsub.addMessageHandler(this.appService);
+    if (this.s2sMessagingService != null && !isInstalled) {
+      this.s2sMessagingService.addMessageHandler(this.appService);
     }
   }
 };
@@ -592,11 +599,11 @@ Crowi.prototype.setupPageService = async function() {
 Crowi.prototype.setupSyncPageStatusService = async function() {
   const SyncPageStatusService = require('../service/system-events/sync-page-status');
   if (this.syncPageStatusService == null) {
-    this.syncPageStatusService = new SyncPageStatusService(this, this.configPubsub, this.socketIoService);
+    this.syncPageStatusService = new SyncPageStatusService(this, this.s2sMessagingService, this.socketIoService);
 
     // add as a message handler
-    if (this.configPubsub != null) {
-      this.configPubsub.addMessageHandler(this.syncPageStatusService);
+    if (this.s2sMessagingService != null) {
+      this.s2sMessagingService.addMessageHandler(this.syncPageStatusService);
     }
   }
 };

src/server/middlewares/auto-reconnect-to-config-pubsub.js

@@ -1,11 +0,0 @@
-module.exports = (crowi) => {
-  const { configPubsub } = crowi;
-
-  return (req, res, next) => {
-    if (configPubsub != null && configPubsub.shouldResubscribe()) {
-      configPubsub.subscribe();
-    }
-
-    return next();
-  };
-};

src/server/middlewares/auto-reconnect-to-s2s-msg-server.js

@@ -0,0 +1,11 @@
+module.exports = (crowi) => {
+  const { s2sMessagingService } = crowi;
+
+  return (req, res, next) => {
+    if (s2sMessagingService != null && s2sMessagingService.shouldResubscribe()) {
+      s2sMessagingService.subscribe();
+    }
+
+    return next();
+  };
+};

src/server/models/vo/config-pubsub-message.js → src/server/models/vo/s2s-message.js

@@ -1,4 +1,4 @@
-class ConfigPubsubMessage {
+class S2sMessage {
 
   constructor(eventName, body = {}) {
     this.eventName = eventName;
@@ -18,9 +18,9 @@ class ConfigPubsubMessage {
       throw new Error('message body must contain \'eventName\'');
     }
 
-    return new ConfigPubsubMessage(body.eventName, body);
+    return new S2sMessage(body.eventName, body);
   }
 
 }
 
-module.exports = ConfigPubsubMessage;
+module.exports = S2sMessage;

src/server/routes/apiv3/app-settings.js

@@ -366,7 +366,7 @@ module.exports = (crowi) => {
     try {
       const { configManager, mailService } = crowi;
 
-      // update config without publishing ConfigPubsubMessage
+      // update config without publishing S2sMessage
       await configManager.updateConfigsInTheSameNamespace('crowi', requestMailSettingParams, true);
 
       await mailService.initialize();
@@ -423,7 +423,7 @@ module.exports = (crowi) => {
     try {
       const { configManager, mailService } = crowi;
 
-      // update config without publishing ConfigPubsubMessage
+      // update config without publishing S2sMessage
       await configManager.updateConfigsInTheSameNamespace('crowi', requestAwsSettingParams, true);
 
       await mailService.initialize();

src/server/routes/apiv3/security-setting.js

@@ -327,7 +327,7 @@ module.exports = (crowi) => {
   async function updateAndReloadStrategySettings(authId, params) {
     const { configManager, passportService } = crowi;
 
-    // update config without publishing ConfigPubsubMessage
+    // update config without publishing S2sMessage
     await configManager.updateConfigsInTheSameNamespace('crowi', params, true);
 
     await passportService.setupStrategyById(authId);

src/server/service/app.js

@@ -2,27 +2,27 @@ const logger = require('@alias/logger')('growi:service:AppService'); // eslint-d
 const { pathUtils } = require('growi-commons');
 
 
-const ConfigPubsubMessage = require('../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('./config-pubsub/handlable');
+const S2sMessage = require('../models/vo/s2s-message');
+const S2sMessageHandlable = require('./s2s-messaging/handlable');
 
 /**
  * the service class of AppService
  */
-class AppService extends ConfigPubsubMessageHandlable {
+class AppService extends S2sMessageHandlable {
 
   constructor(crowi) {
     super();
 
     this.crowi = crowi;
     this.configManager = crowi.configManager;
-    this.configPubsub = crowi.configPubsub;
+    this.s2sMessagingService = crowi.s2sMessagingService;
   }
 
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName } = s2sMessage;
     if (eventName !== 'systemInstalled') {
       return false;
     }
@@ -35,10 +35,10 @@ class AppService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
+  async handleS2sMessage(s2sMessage) {
     logger.info('Invoke post installation process by pubsub notification');
 
-    const { crowi, configManager, configPubsub } = this;
+    const { crowi, configManager, s2sMessagingService } = this;
 
     // load config and setup
     await configManager.loadConfigs();
@@ -48,26 +48,26 @@ class AppService extends ConfigPubsubMessageHandlable {
       crowi.setupAfterInstall();
 
       // remove message handler
-      configPubsub.removeMessageHandler(this);
+      s2sMessagingService.removeMessageHandler(this);
     }
   }
 
   async publishPostInstallationMessage() {
-    const { configPubsub } = this;
+    const { s2sMessagingService } = this;
 
-    if (configPubsub != null) {
-      const configPubsubMessage = new ConfigPubsubMessage('systemInstalled');
+    if (s2sMessagingService != null) {
+      const s2sMessage = new S2sMessage('systemInstalled');
 
       try {
-        await configPubsub.publish(configPubsubMessage);
+        await s2sMessagingService.publish(s2sMessage);
       }
       catch (e) {
-        logger.error('Failed to publish post installation message with configPubsub: ', e.message);
+        logger.error('Failed to publish post installation message with S2sMessagingService: ', e.message);
       }
     }
 
     // remove message handler
-    configPubsub.removeMessageHandler(this);
+    s2sMessagingService.removeMessageHandler(this);
   }
 
   getAppTitle() {

src/server/service/config-loader.js

@@ -131,27 +131,27 @@ const ENV_VAR_NAME_TO_CONFIG_INFO = {
     type:    TYPES.BOOLEAN,
     default: false,
   },
-  CONFIG_PUBSUB_SERVER_TYPE: {
+  S2SMSG_PUBSUB_SERVER_TYPE: {
     ns:      'crowi',
-    key:     'configPubsub:serverType',
+    key:     's2sMessagingPubsub:serverType',
     type:    TYPES.STRING,
     default: null,
   },
-  CONFIG_PUBSUB_NCHAN_PUBLISH_PATH: {
+  S2SMSG_PUBSUB_NCHAN_PUBLISH_PATH: {
     ns:      'crowi',
-    key:     'configPubsub:nchan:publishPath',
+    key:     's2sMessagingPubsub:nchan:publishPath',
     type:    TYPES.STRING,
     default: '/pubsub',
   },
-  CONFIG_PUBSUB_NCHAN_SUBSCRIBE_PATH: {
+  S2SMSG_PUBSUB_NCHAN_SUBSCRIBE_PATH: {
     ns:      'crowi',
-    key:     'configPubsub:nchan:subscribePath',
+    key:     's2sMessagingPubsub:nchan:subscribePath',
     type:    TYPES.STRING,
     default: '/pubsub',
   },
-  CONFIG_PUBSUB_NCHAN_CHANNEL_ID: {
+  S2SMSG_PUBSUB_NCHAN_CHANNEL_ID: {
     ns:      'crowi',
-    key:     'configPubsub:nchan:channelId',
+    key:     's2sMessagingPubsub:nchan:channelId',
     type:    TYPES.STRING,
     default: null,
   },

src/server/service/config-manager.js

@@ -2,8 +2,8 @@ const logger = require('@alias/logger')('growi:service:ConfigManager');
 
 const parseISO = require('date-fns/parseISO');
 
-const ConfigPubsubMessage = require('../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('./config-pubsub/handlable');
+const S2sMessage = require('../models/vo/s2s-message');
+const S2sMessageHandlable = require('./s2s-messaging/handlable');
 
 const ConfigLoader = require('./config-loader');
 
@@ -24,7 +24,7 @@ const KEYS_FOR_SAML_USE_ONLY_ENV_OPTION = [
   'security:passport-saml:ABLCRule',
 ];
 
-class ConfigManager extends ConfigPubsubMessageHandlable {
+class ConfigManager extends S2sMessageHandlable {
 
   constructor(configModel) {
     super();
@@ -52,11 +52,11 @@ class ConfigManager extends ConfigPubsubMessageHandlable {
   }
 
   /**
-   * Set ConfigPubsubDelegator instance
-   * @param {ConfigPubsubDelegator} configPubsub
+   * Set S2sMessagingServiceDelegator instance
+   * @param {S2sMessagingServiceDelegator} s2sMessagingService
    */
-  async setPubsub(configPubsub) {
-    this.configPubsub = configPubsub;
+  async setPubsub(s2sMessagingService) {
+    this.s2sMessagingService = s2sMessagingService;
   }
 
   /**
@@ -182,7 +182,7 @@ class ConfigManager extends ConfigPubsubMessageHandlable {
    *  );
    * ```
    */
-  async updateConfigsInTheSameNamespace(namespace, configs, withoutPublishingConfigPubsubMessage) {
+  async updateConfigsInTheSameNamespace(namespace, configs, withoutPublishingS2sMessage) {
     const queries = [];
     for (const key of Object.keys(configs)) {
       queries.push({
@@ -198,7 +198,7 @@ class ConfigManager extends ConfigPubsubMessageHandlable {
     await this.loadConfigs();
 
     // publish updated date after reloading
-    if (this.configPubsub != null && !withoutPublishingConfigPubsubMessage) {
+    if (this.s2sMessagingService != null && !withoutPublishingS2sMessage) {
       this.publishUpdateMessage();
     }
   }
@@ -311,32 +311,32 @@ class ConfigManager extends ConfigPubsubMessageHandlable {
   }
 
   async publishUpdateMessage() {
-    const configPubsubMessage = new ConfigPubsubMessage('configUpdated', { updatedAt: new Date() });
+    const s2sMessage = new S2sMessage('configUpdated', { updatedAt: new Date() });
 
     try {
-      await this.configPubsub.publish(configPubsubMessage);
+      await s2sMessagingService.publish(s2sMessage);
     }
     catch (e) {
-      logger.error('Failed to publish update message with configPubsub: ', e.message);
+      logger.error('Failed to publish update message with S2sMessagingService: ', e.message);
     }
   }
 
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName, updatedAt } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName, updatedAt } = s2sMessage;
     if (eventName !== 'configUpdated' || updatedAt == null) {
       return false;
     }
 
-    return this.lastLoadedAt == null || this.lastLoadedAt < parseISO(configPubsubMessage.updatedAt);
+    return this.lastLoadedAt == null || this.lastLoadedAt < parseISO(s2sMessage.updatedAt);
   }
 
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
+  async handleS2sMessage(s2sMessage) {
     logger.info('Reload configs by pubsub notification');
     return this.loadConfigs();
   }

src/server/service/config-pubsub/handlable.js

@@ -1,14 +0,0 @@
-// TODO: make interface with TS
-class ConfigPubsubMessageHandlable {
-
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    throw new Error('implement this');
-  }
-
-  async handleConfigPubsubMessage(configPubsubMessage) {
-    throw new Error('implement this');
-  }
-
-}
-
-module.exports = ConfigPubsubMessageHandlable;

src/server/service/customize.js

@@ -3,20 +3,20 @@ const logger = require('@alias/logger')('growi:service:CustomizeService');
 
 const DevidedPagePath = require('@commons/models/devided-page-path');
 
-const ConfigPubsubMessage = require('../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('./config-pubsub/handlable');
+const S2sMessage = require('../models/vo/s2s-message');
+const S2sMessageHandlable = require('./s2s-messaging/handlable');
 
 
 /**
  * the service class of CustomizeService
  */
-class CustomizeService extends ConfigPubsubMessageHandlable {
+class CustomizeService extends S2sMessageHandlable {
 
   constructor(crowi) {
     super();
 
     this.configManager = crowi.configManager;
-    this.configPubsub = crowi.configPubsub;
+    this.s2sMessagingService = crowi.s2sMessagingService;
     this.appService = crowi.appService;
     this.xssService = crowi.xssService;
 
@@ -26,19 +26,19 @@ class CustomizeService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName, updatedAt } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName, updatedAt } = s2sMessage;
     if (eventName !== 'customizeServiceUpdated' || updatedAt == null) {
       return false;
     }
 
-    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(configPubsubMessage.updatedAt);
+    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(s2sMessage.updatedAt);
   }
 
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
+  async handleS2sMessage(s2sMessage) {
     const { configManager } = this;
 
     logger.info('Reset customized value by pubsub notification');
@@ -48,16 +48,16 @@ class CustomizeService extends ConfigPubsubMessageHandlable {
   }
 
   async publishUpdatedMessage() {
-    const { configPubsub } = this;
+    const { s2sMessagingService } = this;
 
-    if (configPubsub != null) {
-      const configPubsubMessage = new ConfigPubsubMessage('customizeServiceUpdated', { updatedAt: new Date() });
+    if (s2sMessagingService != null) {
+      const s2sMessage = new S2sMessage('customizeServiceUpdated', { updatedAt: new Date() });
 
       try {
-        await configPubsub.publish(configPubsubMessage);
+        await s2sMessagingService.publish(s2sMessage);
       }
       catch (e) {
-        logger.error('Failed to publish update message with configPubsub: ', e.message);
+        logger.error('Failed to publish update message with S2sMessagingService: ', e.message);
       }
     }
   }

src/server/service/mail.js

@@ -4,18 +4,18 @@ const nodemailer = require('nodemailer');
 const swig = require('swig-templates');
 
 
-const ConfigPubsubMessage = require('../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('./config-pubsub/handlable');
+const S2sMessage = require('../models/vo/s2s-message');
+const S2sMessageHandlable = require('./s2s-messaging/handlable');
 
 
-class MailService extends ConfigPubsubMessageHandlable {
+class MailService extends S2sMessageHandlable {
 
   constructor(crowi) {
     super();
 
     this.appService = crowi.appService;
     this.configManager = crowi.configManager;
-    this.configPubsub = crowi.configPubsub;
+    this.s2sMessagingService = crowi.s2sMessagingService;
 
     this.mailConfig = {};
     this.mailer = {};
@@ -26,19 +26,19 @@ class MailService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName, updatedAt } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName, updatedAt } = s2sMessage;
     if (eventName !== 'mailServiceUpdated' || updatedAt == null) {
       return false;
     }
 
-    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(configPubsubMessage.updatedAt);
+    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(s2sMessage.updatedAt);
   }
 
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
+  async handleS2sMessage(s2sMessage) {
     const { configManager } = this;
 
     logger.info('Initialize mail settings by pubsub notification');
@@ -47,16 +47,16 @@ class MailService extends ConfigPubsubMessageHandlable {
   }
 
   async publishUpdatedMessage() {
-    const { configPubsub } = this;
+    const { s2sMessagingService } = this;
 
-    if (configPubsub != null) {
-      const configPubsubMessage = new ConfigPubsubMessage('mailServiceUpdated', { updatedAt: new Date() });
+    if (s2sMessagingService != null) {
+      const s2sMessage = new S2sMessage('mailServiceUpdated', { updatedAt: new Date() });
 
       try {
-        await configPubsub.publish(configPubsubMessage);
+        await s2sMessagingService.publish(s2sMessage);
       }
       catch (e) {
-        logger.error('Failed to publish update message with configPubsub: ', e.message);
+        logger.error('Failed to publish update message with S2sMessagingService: ', e.message);
       }
     }
   }

src/server/service/passport.js

@@ -13,13 +13,13 @@ const SamlStrategy = require('passport-saml').Strategy;
 const OIDCIssuer = require('openid-client').Issuer;
 const BasicStrategy = require('passport-http').BasicStrategy;
 
-const ConfigPubsubMessage = require('../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('./config-pubsub/handlable');
+const S2sMessage = require('../models/vo/s2s-message');
+const S2sMessageHandlable = require('./s2s-messaging/handlable');
 
 /**
  * the service class of Passport
  */
-class PassportService extends ConfigPubsubMessageHandlable {
+class PassportService extends S2sMessageHandlable {
 
   // see '/lib/form/login.js'
   static get USERNAME_FIELD() { return 'loginForm[username]' }
@@ -129,21 +129,21 @@ class PassportService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName, updatedAt, strategyId } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName, updatedAt, strategyId } = s2sMessage;
     if (eventName !== 'passportServiceUpdated' || updatedAt == null || strategyId == null) {
       return false;
     }
 
-    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(configPubsubMessage.updatedAt);
+    return this.lastLoadedAt == null || this.lastLoadedAt < new Date(s2sMessage.updatedAt);
   }
 
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
+  async handleS2sMessage(s2sMessage) {
     const { configManager } = this.crowi;
-    const { strategyId } = configPubsubMessage;
+    const { strategyId } = s2sMessage;
 
     logger.info('Reset strategy by pubsub notification');
     await configManager.loadConfigs();
@@ -151,19 +151,19 @@ class PassportService extends ConfigPubsubMessageHandlable {
   }
 
   async publishUpdatedMessage(strategyId) {
-    const { configPubsub } = this.crowi;
+    const { s2sMessagingService } = this.crowi;
 
-    if (configPubsub != null) {
-      const configPubsubMessage = new ConfigPubsubMessage('passportStrategyReloaded', {
+    if (s2sMessagingService != null) {
+      const s2sMessage = new S2sMessage('passportStrategyReloaded', {
         updatedAt: new Date(),
         strategyId,
       });
 
       try {
-        await configPubsub.publish(configPubsubMessage);
+        await s2sMessagingService.publish(s2sMessage);
       }
       catch (e) {
-        logger.error('Failed to publish update message with configPubsub: ', e.message);
+        logger.error('Failed to publish update message with S2sMessagingService: ', e.message);
       }
     }
   }

src/server/service/config-pubsub/base.js → src/server/service/s2s-messaging/base.js

@@ -1,8 +1,8 @@
-const logger = require('@alias/logger')('growi:service:config-pubsub:base');
+const logger = require('@alias/logger')('growi:service:s2s-messaging:base');
 
-const ConfigPubsubMessageHandlable = require('../config-pubsub/handlable');
+const S2sMessageHandlable = require('./handlable');
 
-class ConfigPubsubDelegator {
+class S2sMessagingServiceDelegator {
 
   constructor(uri) {
     this.uid = Math.floor(Math.random() * 100000);
@@ -25,18 +25,18 @@ class ConfigPubsubDelegator {
 
   /**
    * Publish message
-   * @param {ConfigPubsubMessage} configPubsubMessage
+   * @param {S2sMessage} s2sMessage
    */
-  async publish(configPubsubMessage) {
-    configPubsubMessage.setPublisherUid(this.uid);
+  async publish(s2sMessage) {
+    s2sMessage.setPublisherUid(this.uid);
   }
 
   /**
    * Add message handler
-   * @param {ConfigPubsubMessageHandlable} handlable
+   * @param {S2sMessageHandlable} handlable
    */
   addMessageHandler(handlable) {
-    if (!(handlable instanceof ConfigPubsubMessageHandlable)) {
+    if (!(handlable instanceof S2sMessageHandlable)) {
       logger.warn('Unsupported instance');
       logger.debug('Unsupported instance: ', handlable);
       return;
@@ -47,10 +47,10 @@ class ConfigPubsubDelegator {
 
   /**
    * Remove message handler
-   * @param {ConfigPubsubMessageHandlable} handlable
+   * @param {S2sMessageHandlable} handlable
    */
   removeMessageHandler(handlable) {
-    if (!(handlable instanceof ConfigPubsubMessageHandlable)) {
+    if (!(handlable instanceof S2sMessageHandlable)) {
       logger.warn('Unsupported instance');
       logger.debug('Unsupported instance: ', handlable);
       return;
@@ -61,4 +61,4 @@ class ConfigPubsubDelegator {
 
 }
 
-module.exports = ConfigPubsubDelegator;
+module.exports = S2sMessagingServiceDelegator;

src/server/service/s2s-messaging/handlable.js

@@ -0,0 +1,14 @@
+// TODO: make interface with TS
+class S2sMessageHandlable {
+
+  shouldHandleS2sMessage(s2sMessage) {
+    throw new Error('implement this');
+  }
+
+  async handleS2sMessage(s2sMessage) {
+    throw new Error('implement this');
+  }
+
+}
+
+module.exports = S2sMessageHandlable;

src/server/service/config-pubsub/index.js → src/server/service/s2s-messaging/index.js

@@ -1,14 +1,14 @@
-const logger = require('@alias/logger')('growi:service:ConfigPubsubFactory');
+const logger = require('@alias/logger')('growi:service:s2s-messaging:S2sMessagingServiceFactory');
 
 const envToModuleMappings = {
   redis:   'redis',
   nchan:   'nchan',
 };
 
-class ConfigPubsubFactory {
+class S2sMessagingServiceFactory {
 
   initializeDelegator(crowi) {
-    const type = crowi.configManager.getConfig('crowi', 'configPubsub:serverType');
+    const type = crowi.configManager.getConfig('crowi', 's2sMessagingPubsub:serverType');
 
     if (type == null) {
       logger.info('Config pub/sub server is not defined.');
@@ -36,7 +36,7 @@ class ConfigPubsubFactory {
 
 }
 
-const factory = new ConfigPubsubFactory();
+const factory = new S2sMessagingServiceFactory();
 
 module.exports = (crowi) => {
   return factory.getDelegator(crowi);

src/server/service/config-pubsub/nchan.js → src/server/service/s2s-messaging/nchan.js

@@ -1,4 +1,4 @@
-const logger = require('@alias/logger')('growi:service:config-pubsub:nchan');
+const logger = require('@alias/logger')('growi:service:s2s-messaging:nchan');
 
 const path = require('path');
 const axios = require('axios');
@@ -6,11 +6,11 @@ const axios = require('axios');
 const WebSocket = require('ws');
 const ReconnectingWebSocket = require('reconnecting-websocket');
 
-const ConfigPubsubMessage = require('../../models/vo/config-pubsub-message');
-const ConfigPubsubDelegator = require('./base');
+const S2sMessage = require('../../models/vo/s2s-message');
+const S2sMessagingServiceDelegator = require('./base');
 
 
-class NchanDelegator extends ConfigPubsubDelegator {
+class NchanDelegator extends S2sMessagingServiceDelegator {
 
   constructor(uri, publishPath, subscribePath, channelId) {
     super(uri);
@@ -21,7 +21,7 @@ class NchanDelegator extends ConfigPubsubDelegator {
     this.channelId = channelId;
 
     /**
-     * A list of ConfigPubsubHandler instance
+     * A list of S2sMessageHandlable instance
      */
     this.handlableToEventListenerMap = {};
 
@@ -60,14 +60,14 @@ class NchanDelegator extends ConfigPubsubDelegator {
   /**
    * @inheritdoc
    */
-  async publish(configPubsubMessage) {
-    await super.publish(configPubsubMessage);
+  async publish(s2sMessage) {
+    await super.publish(s2sMessage);
 
     const url = this.constructUrl(this.publishPath).toString();
 
-    logger.debug('Publish message', configPubsubMessage, `to ${url}`);
+    logger.debug('Publish message', s2sMessage, `to ${url}`);
 
-    return axios.post(url, configPubsubMessage);
+    return axios.post(url, s2sMessage);
   }
 
   /**
@@ -144,29 +144,29 @@ class NchanDelegator extends ConfigPubsubDelegator {
   }
 
   /**
-   * Handle message string with the specified ConfigPubsubHandler
+   * Handle message string with the specified S2sMessageHandlable
    *
    * @see https://github.com/theturtle32/WebSocket-Node/blob/1f7ffba2f7a6f9473bcb39228264380ce2772ba7/docs/WebSocketConnection.md#message
    *
    * @param {object} message WebSocket-Node message object
-   * @param {ConfigPubsubHandler} handlable
+   * @param {S2sMessageHandlable} handlable
    */
   handleMessage(message, handlable) {
     try {
-      const configPubsubMessage = ConfigPubsubMessage.parse(message.data);
+      const s2sMessage = S2sMessage.parse(message.data);
 
       // check uid
-      if (configPubsubMessage.publisherUid === this.uid) {
+      if (s2sMessage.publisherUid === this.uid) {
         logger.debug(`Skip processing by ${handlable.constructor.name} because this message is sent by the publisher itself:`, `from ${this.uid}`);
         return;
       }
 
-      // check shouldHandleConfigPubsubMessage
-      const shouldHandle = handlable.shouldHandleConfigPubsubMessage(configPubsubMessage);
-      logger.debug(`${handlable.constructor.name}.shouldHandleConfigPubsubMessage(`, configPubsubMessage, `) => ${shouldHandle}`);
+      // check shouldHandleS2sMessage
+      const shouldHandle = handlable.shouldHandleS2sMessage(s2sMessage);
+      logger.debug(`${handlable.constructor.name}.shouldHandleS2sMessage(`, s2sMessage, `) => ${shouldHandle}`);
 
       if (shouldHandle) {
-        handlable.handleConfigPubsubMessage(configPubsubMessage);
+        handlable.handleS2sMessage(s2sMessage);
       }
     }
     catch (err) {
@@ -187,9 +187,9 @@ module.exports = function(crowi) {
     return;
   }
 
-  const publishPath = configManager.getConfig('crowi', 'configPubsub:nchan:publishPath');
-  const subscribePath = configManager.getConfig('crowi', 'configPubsub:nchan:subscribePath');
-  const channelId = configManager.getConfig('crowi', 'configPubsub:nchan:channelId');
+  const publishPath = configManager.getConfig('crowi', 's2sMessagingPubsub:nchan:publishPath');
+  const subscribePath = configManager.getConfig('crowi', 's2sMessagingPubsub:nchan:subscribePath');
+  const channelId = configManager.getConfig('crowi', 's2sMessagingPubsub:nchan:channelId');
 
   return new NchanDelegator(uri, publishPath, subscribePath, channelId);
 };

src/server/service/config-pubsub/redis.js → src/server/service/s2s-messaging/redis.js

@@ -1,4 +1,4 @@
-const logger = require('@alias/logger')('growi:service:config-pubsub:redis');
+const logger = require('@alias/logger')('growi:service:s2s-messaging:redis');
 
 module.exports = function(crowi) {
   logger.warn('Config pub/sub with Redis has not implemented yet.');

src/server/service/system-events/sync-page-status.js

@@ -1,15 +1,15 @@
 const logger = require('@alias/logger')('growi:service:system-events:SyncPageStatusService');
 
-const ConfigPubsubMessage = require('../../models/vo/config-pubsub-message');
-const ConfigPubsubMessageHandlable = require('../config-pubsub/handlable');
+const S2sMessage = require('../../models/vo/s2s-message');
+const S2sMessageHandlable = require('../s2s-messaging/handlable');
 
-class SyncPageStatusService extends ConfigPubsubMessageHandlable {
+class SyncPageStatusService extends S2sMessageHandlable {
 
-  constructor(crowi, configPubsub, socketIoService) {
+  constructor(crowi, s2sMessagingService, socketIoService) {
     super();
 
     this.crowi = crowi;
-    this.configPubsub = configPubsub;
+    this.s2sMessagingService = s2sMessagingService;
     this.socketIoService = socketIoService;
 
     this.emitter = crowi.events.page;
@@ -20,8 +20,8 @@ class SyncPageStatusService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  shouldHandleConfigPubsubMessage(configPubsubMessage) {
-    const { eventName } = configPubsubMessage;
+  shouldHandleS2sMessage(s2sMessage) {
+    const { eventName } = s2sMessage;
     if (eventName !== 'pageStatusUpdated') {
       return false;
     }
@@ -32,8 +32,8 @@ class SyncPageStatusService extends ConfigPubsubMessageHandlable {
   /**
    * @inheritdoc
    */
-  async handleConfigPubsubMessage(configPubsubMessage) {
-    const { socketIoEventName, page, user } = configPubsubMessage;
+  async handleS2sMessage(s2sMessage) {
+    const { socketIoEventName, page, user } = s2sMessage;
     const { socketIoService } = this;
 
     // emit the updated information to clients
@@ -41,16 +41,16 @@ class SyncPageStatusService extends ConfigPubsubMessageHandlable {
   }
 
   async publishToOtherServers(socketIoEventName, page, user) {
-    const { configPubsub } = this;
+    const { s2sMessagingService } = this;
 
-    if (configPubsub != null) {
-      const configPubsubMessage = new ConfigPubsubMessage('pageStatusUpdated', { socketIoEventName, page, user });
+    if (s2sMessagingService != null) {
+      const s2sMessage = new S2sMessage('pageStatusUpdated', { socketIoEventName, page, user });
 
       try {
-        await configPubsub.publish(configPubsubMessage);
+        await s2sMessagingService.publish(s2sMessage);
       }
       catch (e) {
-        logger.error('Failed to publish update message with configPubsub: ', e.message);
+        logger.error('Failed to publish update message with S2sMessagingService: ', e.message);
       }
     }
   }

src/test/service/config-manager.test.js

@@ -18,7 +18,7 @@ describe('ConfigManager test', () => {
     const configModelMock = {};
 
     beforeEach(async(done) => {
-      configManager.configPubsub = {};
+      configManager.s2sMessagingService = {};
 
       // prepare mocks for updateConfigsInTheSameNamespace method
       configManager.configModel = configModelMock;