src/src/org/ultramonkey/l7/model/L7SyncManager.java

   1 package org.ultramonkey.l7.model;
   2
   3 import java.net.*;
   4 import java.util.HashSet;
   5 import java.util.Vector;
   6
   7 import org.apache.log4j.Logger;
   8 import org.ultramonkey.l7.controller.DirectorController;
   9 import org.ultramonkey.l7.controller.DirectorData;
  10 import org.ultramonkey.l7.controller.L7vsConfController;
  11 import org.ultramonkey.l7.controller.L7vsConfData;
  12 import org.ultramonkey.l7.controller.LogSet;
  13
  14 /**
  15  * <p>class L7SyncManager</p>
  16  * <p>Copyright(c) NTT COMWARE 2008</p>
  17  * @author momose
  18  */
  19 public class L7SyncManager {
  20     protected Logger debugLogger = Logger.getLogger(LogCategorySet.SYNC_SYNC);
  21
  22     protected Logger debugDirectorLogger = Logger
  23                     .getLogger(LogCategorySet.SYNC_SYNC_DIRECTOR_DATA);
  24
  25     protected Logger debugL7vsdConfLogger = Logger
  26                     .getLogger(LogCategorySet.SYNC_SYNC_L7VSDCONF_DATA);
  27
  28     protected Logger debugUserLogger = Logger
  29                     .getLogger(LogCategorySet.SYNC_SYNC_USER_DATA);
  30
  31     protected String categoryName;
  32
  33     protected String actHost;
  34
  35     protected String sbyHost;
  36
  37     protected int sbyPort;
  38
  39     protected Logger logger = Logger.getLogger(LogCategorySet.SYNC_SYNC);
  40
  41     protected Logger directorLogger = Logger
  42                     .getLogger(LogCategorySet.SYNC_SYNC_DIRECTOR_DATA);
  43
  44     protected Logger l7vsdConfLogger = Logger
  45                     .getLogger(LogCategorySet.SYNC_SYNC_L7VSDCONF_DATA);
  46
  47     protected Logger userLogger = Logger.getLogger(LogCategorySet.SYNC_SYNC_USER_DATA);
  48
  49     protected enum SyncDataType {
  50         DIRECTORDATA, L7VSCONFDATA, USERDATA
  51     };
  52
  53     /**
  54      * Constructor gets data from Parameter class
  55      *
  56      */
  57     public L7SyncManager() {
  58         //      debug log(constructor)
  59         if (debugLogger.isDebugEnabled()) {
  60             debugLogger.debug("11058 class L7SyncManager created.");
  61         }
  62
  63         Parameter parameter = Parameter.getInstance();
  64         actHost = parameter.getValue("actHost");
  65         sbyHost = parameter.getValue("sbyHost");
  66         sbyPort = Integer.parseInt(parameter.getValue("sbyPort"));
  67     }
  68
  69     /**
  70      * <p> Active server sends synchronous data from active server to stand-by server. It recieves results from stand-by server.</p>
  71      *
  72      * @param categoryIdSet category IDs of synchronous data
  73      * @throws MessageView
  74      */
  75     public void syncAct(HashSet<Integer> categoryIdSet) throws MessageView {
  76         //      debug log(in method)
  77         if (debugLogger.isDebugEnabled()) {
  78             StringBuffer buf = new StringBuffer();
  79             buf
  80                             .append("L7SyncManager::syncAct(HashSet<Integer> categoryIdSet) throws MessageView in ");
  81             buf.append("categoryIdSet= " + categoryIdSet.toString());
  82             debugLogger.debug("11059 " + buf.toString());
  83         }
  84
  85         Vector<Payload> payloadVec = new Vector<Payload>();
  86         Payload payload = null;
  87         L7SyncSocket l7SyncSocket = new L7SyncSocket();
  88
  89         for (int categoryId : categoryIdSet) {
  90             switch (getDataTypeFromId(categoryId)) {
  91             case DIRECTORDATA:
  92                 try {
  93                     DirectorController directorController = new DirectorController();
  94                     payload = new Payload(categoryId, directorController
  95                                     .getDirectorData());
  96                 } catch (Exception e) {
  97                     logger.error("41007 " + Message.SYNC_SET_ERROR + "DirectorData : " + e);
  98                     throw new MessageView(40012, LogCategorySet.SYNC_START_STOP,
  99                                     Message.SYNC_SET_ERROR + " DirectorData :" + e);
 100                 }
 101                 break;
 102
 103             case L7VSCONFDATA:
 104                 L7vsConfController l7vsConfController = new L7vsConfController();
 105                 try {
 106                     payload = new Payload(categoryId, l7vsConfController.getConfData());
 107                 } catch (FileNotReadException e) {
 108                     logger.error("41008 " + Message.SYNC_SET_ERROR + "L7vsConfData : " + e);
 109                     throw new MessageView(40013, LogCategorySet.SYNC_SYNC,
 110                                     Message.SYNC_GET_ERROR + " L7vsConfData :" + e);
 111                 }
 112                 break;
 113
 114             case USERDATA:
 115                 try {
 116                     UserManager userManager = new UserManager();
 117                     payload = new Payload(categoryId, userManager.getUserList());
 118                 } catch (FileNotReadException e) {
 119                     logger.error("41009 " + Message.SYNC_SET_ERROR + "L7vsdConfData : " + e);
 120                     throw new MessageView(40030, LogCategorySet.SYNC_SYNC,
 121                                     Message.SYNC_GET_ERROR + " UserData :" + e);
 122                 }
 123                 break;
 124
 125             default:
 126                 throw new MessageView(40027, LogCategorySet.SYNC_START_STOP,
 127                                 Message.SYNC_INVALID_CATEGORY_ID);
 128             }
 129             payloadVec.add(payload);
 130         }
 131         try {
 132                 if (sbyHost == null)
 133                         throw new ConnectException();
 134             Socket socket = new Socket(sbyHost, sbyPort);
 135             l7SyncSocket
 136                             .openConnection(socket.getInputStream(), socket
 137                                             .getOutputStream());
 138         } catch (Exception e) {
 139             logger.error("41010 " + Message.SYNC_OPEN_ERROR + " : " + e);
 140             throw new MessageView(40014, LogCategorySet.SYNC_START_STOP,
 141                             Message.SYNC_OPEN_ERROR);
 142         }
 143         sendRecv(l7SyncSocket, payloadVec);
 144
 145         try {
 146             l7SyncSocket.closeConnection();
 147         } catch (MessageView m) {
 148             logger.error("41011 " + m.message);
 149             throw m;
 150         }
 151
 152         //      debug log(out method)
 153         if (debugLogger.isDebugEnabled()) {
 154             StringBuffer buf = new StringBuffer();
 155             buf
 156                             .append("L7SyncManager::syncAct(HashSet<Integer> categoryIdSet) throws MessageView out ");
 157             debugLogger.debug("11060 " + buf.toString());
 158         }
 159
 160     }
 161
 162     /**
 163      * <p> Stand-by server recieves synchronous data from active server. It compares synchronous data. It updates stand-by data if there are any differences between active server settings and stand-by server settings.</p>
 164      *
 165      * @throws MessageView
 166      */
 167     public void syncSby() throws MessageView {
 168         //      debug log(in method)
 169         if (debugLogger.isDebugEnabled()) {
 170             StringBuffer buf = new StringBuffer();
 171             buf.append("L7SyncManager::syncSby() throws MessageView in ");
 172             debugLogger.debug("11061 " + buf.toString());
 173         }
 174
 175         L7SyncSocket l7SyncSocket = new L7SyncSocket();
 176         Payload recvPayload = null;
 177         Payload sendPayload;
 178         String[] recvData;
 179         Object sbyData;
 180
 181         try {
 182             l7SyncSocket.openConnection(System.in, System.out);
 183         } catch (MessageView m) {
 184             logger.error("41012 " + m.message);
 185             throw m;
 186         }
 187
 188         while (null != (recvData = l7SyncSocket.recvData())) {
 189             try {
 190                 recvPayload = new Payload(recvData);
 191                 switch (getDataTypeFromId(recvPayload.categoryId)) {
 192                 case DIRECTORDATA:
 193                     DirectorController directorController = new DirectorController();
 194                     try {
 195                         DirectorData sbyDirectorData = compareDirectorData(recvPayload,
 196                                         directorController.getDirectorData());
 197                         if (null != sbyDirectorData) {
 198                             directorController.setDirectorData(sbyDirectorData);
 199                         }
 200                     } catch (Exception e) {
 201                         throw new MessageView(40015, LogCategorySet.SYNC_START_STOP,
 202                                         Message.SYNC_GET_ERROR + " DirectorData");
 203                     }
 204                     break;
 205
 206                 case L7VSCONFDATA:
 207                     L7vsConfController l7vsConfController = new L7vsConfController();
 208                     try {
 209                         L7vsConfData sbyL7vsConfData = compareL7vsConfData(recvPayload,
 210                                         l7vsConfController.getConfData());
 211                         if (null != sbyL7vsConfData) {
 212                             l7vsConfController.setConfData(sbyL7vsConfData);
 213                         }
 214                     } catch (FileNotReadException e) {
 215                         throw new MessageView(40016, LogCategorySet.SYNC_SYNC,
 216                                         Message.SYNC_GET_ERROR + " L7vsConfData :" + e);
 217                     } catch (FileNotWriteException e) {
 218                         throw new MessageView(40017, LogCategorySet.SYNC_SYNC,
 219                                         Message.SYNC_SET_ERROR + " L7vsConfData :" + e);
 220                     }
 221                     break;
 222
 223                 case USERDATA:
 224                     try {
 225                         UserManager userManager = new UserManager();
 226                         Vector<UserData> sbyUserVec = compareUserData(recvPayload,
 227                                         userManager.getUserList());
 228                         if (null != sbyUserVec) {
 229                             userManager.setUserList(sbyUserVec);
 230                         }
 231                     } catch (Exception e) {
 232                         throw new MessageView(40018, LogCategorySet.SYNC_START_STOP,
 233                                         Message.SYNC_GET_ERROR + " userdata");
 234                     }
 235                     break;
 236                 default:
 237                     throw new MessageView(40028, LogCategorySet.SYNC_START_STOP,
 238                                     Message.SYNC_INVALID_CATEGORY_ID);
 239                 }
 240                 sendPayload = new Payload(SyncCategoryIdSet.SYNC_OK, new DirectorData());
 241                 logger.info("21001 " + SyncCategoryIdSet.toCategoryName(recvPayload.categoryId)
 242                                 + Message.SYNC_SUCCESS);
 243
 244             } catch (MessageView m) {
 245                 logger.error("41013 " + m.message);
 246                 sendPayload = new Payload(SyncCategoryIdSet.SYNC_NG, new DirectorData());
 247             }
 248
 249             l7SyncSocket.sendData(sendPayload.getMessage());
 250         }
 251         //      debug log(out method)
 252         if (debugLogger.isDebugEnabled()) {
 253             StringBuffer buf = new StringBuffer();
 254             buf.append("L7SyncManager::syncSby() throws MessageView out ");
 255             debugLogger.debug("11062 " + buf.toString());
 256         }
 257
 258     }
 259
 260     /**
 261      * <p>  Sends synchronous data and recieves results from stand-by server. </p>
 262      *
 263      * @param l7SyncSocket
 264      * @param payloadVec synchronous data
 265      * @throws MessageView
 266      */
 267     protected void sendRecv(L7SyncSocket l7SyncSocket, Vector<Payload> payloadVec)
 268                     throws MessageView {
 269         //      debug log(in method)
 270         if (debugLogger.isDebugEnabled()) {
 271             StringBuffer buf = new StringBuffer();
 272             buf
 273                             .append("L7SyncManager::sendRecv(L7SyncSocket l7SyncSocket, Vector<Payload> payloadVec) throws MessageView in ");
 274             buf.append("l7SyncSocket= " + l7SyncSocket.toString() + ", ");
 275             buf.append("payloadVec= " + payloadVec.toString());
 276             debugLogger.debug("11063 " + buf.toString());
 277         }
 278
 279         Payload recvPayload;
 280         for (Payload payload : payloadVec) {
 281             l7SyncSocket.sendData(payload.getMessage());
 282             recvPayload = new Payload(l7SyncSocket.recvData());
 283             switch (recvPayload.categoryId) {
 284             case SyncCategoryIdSet.SYNC_NG:
 285                 logger.error("41014 " + Message.SYNC_FAIL + " : "
 286                                 + SyncCategoryIdSet.toCategoryName(payload.categoryId));
 287                 throw new MessageView(
 288                                 40019,
 289                                 LogCategorySet.SYNC_CONNECTION,
 290                                 Message.SYNC_FAIL
 291                                                 + " : "
 292                                                 + SyncCategoryIdSet
 293                                                                 .toCategoryName(payload.categoryId));
 294             case SyncCategoryIdSet.SYNC_OK:
 295                 logger.info("21002 " + SyncCategoryIdSet.toCategoryName(payload.categoryId)
 296                                 + Message.SYNC_SUCCESS);
 297                 break;
 298             default:
 299                 throw new MessageView(40029, LogCategorySet.SYNC_START_STOP,
 300                                 Message.SYNC_INVALID_CATEGORY_ID);
 301             }
 302         }
 303         //      debug log(out method)
 304         if (debugLogger.isDebugEnabled()) {
 305             StringBuffer buf = new StringBuffer();
 306             buf
 307                             .append("L7SyncManager::sendRecv(L7SyncSocket l7SyncSocket, Vector<Payload> payloadVec) throws MessageView out ");
 308             debugLogger.debug("11064 " + buf.toString());
 309         }
 310
 311     }
 312
 313     /**
 314      * <p> Compares DirectorData settings in active server with those in stand-by server. Updates DirectorData in stand-by server if there are any differences between them.</p>
 315      *
 316      * @param categoryId category ID of synchronous data
 317      * @param recvData recieve data from active server
 318      * @throws MessageView
 319      */
 320     protected DirectorData compareDirectorData(Payload recvData,
 321                     DirectorData sbyDirectorData) throws MessageView {
 322         //      debug log(in method)
 323         if (debugDirectorLogger.isDebugEnabled()) {
 324             StringBuffer buf = new StringBuffer();
 325             buf
 326                             .append("L7SyncManager::compareDirectorData(Payload recvData, DirectorData sbyDirectorData) throws MessageView in ");
 327             buf.append("recvData= " + recvData.toString() + ", ");
 328             buf.append("sbyDirectorData= " + sbyDirectorData.toString());
 329             debugDirectorLogger.debug("11065 " + buf.toString());
 330         }
 331
 332         DirectorData actDirectorData = recvData.getDirectorData();
 333         boolean needSync = false;
 334
 335         switch (recvData.categoryId) {
 336         case SyncCategoryIdSet.MONITOR_ID:
 337             if (actDirectorData.checkTimeOut != sbyDirectorData.checkTimeOut) {
 338                 directorLogger.info("21003 " + Message.SYNC_DIFFERENT_DATA + " : checkTimeOut ");
 339                 sbyDirectorData.checkTimeOut = actDirectorData.checkTimeOut;
 340                 needSync = true;
 341             }
 342             if (actDirectorData.negotiateTimeOut != sbyDirectorData.negotiateTimeOut) {
 343                 directorLogger.info("21004 " + Message.SYNC_DIFFERENT_DATA + " : negotiateTimeOut ");
 344                 sbyDirectorData.negotiateTimeOut = actDirectorData.negotiateTimeOut;
 345                 needSync = true;
 346             }
 347             if (actDirectorData.checkInterval != sbyDirectorData.checkInterval) {
 348                 directorLogger.info("21005 " + Message.SYNC_DIFFERENT_DATA + " : checkInterval ");
 349                 sbyDirectorData.checkInterval = actDirectorData.checkInterval;
 350                 needSync = true;
 351             }
 352             if (actDirectorData.checkCount != sbyDirectorData.checkCount) {
 353                 directorLogger.info("21006 " + Message.SYNC_DIFFERENT_DATA + " : checkCount ");
 354                 sbyDirectorData.checkCount = actDirectorData.checkCount;
 355                 needSync = true;
 356             }
 357             if (actDirectorData.autoreload != sbyDirectorData.autoreload) {
 358                 directorLogger.info("21007 " + Message.SYNC_DIFFERENT_DATA + " : autoreload ");
 359                 sbyDirectorData.autoreload = actDirectorData.autoreload;
 360                 needSync = true;
 361             }
 362             if (!actDirectorData.callback.equals(sbyDirectorData.callback)) {
 363                 directorLogger.info("21008 " + Message.SYNC_DIFFERENT_DATA + " : callback ");
 364                 sbyDirectorData.callback = actDirectorData.callback;
 365                 needSync = true;
 366             }
 367             if (!actDirectorData.fallback.equals(sbyDirectorData.fallback)) {
 368                 directorLogger.info("21009 " + Message.SYNC_DIFFERENT_DATA + " : fallback ");
 369                 sbyDirectorData.fallback = actDirectorData.fallback;
 370                 needSync = true;
 371             }
 372             if (!actDirectorData.logfile.equals(sbyDirectorData.logfile)) {
 373                 directorLogger.info("21010 " + Message.SYNC_DIFFERENT_DATA + " : logfile ");
 374                 sbyDirectorData.logfile = actDirectorData.logfile;
 375                 needSync = true;
 376             }
 377             if (!actDirectorData.execute.equals(sbyDirectorData.execute)) {
 378                 directorLogger.info("21011 " + Message.SYNC_DIFFERENT_DATA + " : execute ");
 379                 sbyDirectorData.execute = actDirectorData.execute;
 380                 needSync = true;
 381             }
 382             if (!actDirectorData.supervised.equals(sbyDirectorData.supervised)) {
 383                 directorLogger.info("21012 " + Message.SYNC_DIFFERENT_DATA + " : supervised ");
 384                 sbyDirectorData.supervised = actDirectorData.supervised;
 385                 needSync = true;
 386             }
 387             if (!actDirectorData.quiescent.equals(sbyDirectorData.quiescent)) {
 388                 directorLogger.info("21013 " + Message.SYNC_DIFFERENT_DATA + " : quiescent ");
 389                 sbyDirectorData.quiescent = actDirectorData.quiescent;
 390                 needSync = true;
 391             }
 392             break;
 393
 394         case SyncCategoryIdSet.SERVICE_ID:
 395             if (actDirectorData.virtualSettings.size() != sbyDirectorData.virtualSettings
 396                             .size()) {
 397                 sbyDirectorData.virtualSettings = actDirectorData.virtualSettings;
 398                 directorLogger.info("21014 " + Message.SYNC_DIFFERENT_DATA + " : virtualSettings ");
 399                 needSync = true;
 400             } else {
 401                 if (!actDirectorData.virtualSettings
 402                                 .equals(sbyDirectorData.virtualSettings)) {
 403                     sbyDirectorData.virtualSettings = actDirectorData.virtualSettings;
 404                     needSync = true;
 405                 }
 406             }
 407             break;
 408
 409         default:
 410             throw new MessageView(40020, LogCategorySet.SYNC_SYNC_DIRECTOR_DATA,
 411                             Message.SYNC_INVALID_CATEGORY_ID);
 412         }
 413         if (!needSync) {
 414             directorLogger.info("21015 " + Message.SYNC_SAME_DATA + " : "
 415                             + SyncCategoryIdSet.toCategoryName(recvData.categoryId));
 416
 417             //      debug log(out method)
 418             if (debugDirectorLogger.isDebugEnabled()) {
 419                 StringBuffer buf = new StringBuffer();
 420                 buf
 421                                 .append("L7SyncManager::compareDirectorData(Payload recvData, DirectorData sbyDirectorData) throws MessageView out ");
 422                 buf.append("return= null");
 423                 debugDirectorLogger.debug("11066 " + buf.toString());
 424             }
 425             return null;
 426         }
 427
 428         //      debug log(out method)
 429         if (debugDirectorLogger.isDebugEnabled()) {
 430             StringBuffer buf = new StringBuffer();
 431             buf
 432                             .append("L7SyncManager::compareDirectorData(Payload recvData, DirectorData sbyDirectorData) throws MessageView out ");
 433             buf.append("return= " + sbyDirectorData.toString());
 434             debugDirectorLogger.debug("11067 " + buf.toString());
 435         }
 436
 437         return sbyDirectorData;
 438     }
 439
 440     /**
 441      * <p> Compares UserData settings in active server with those in stand-by server. Updates UserData in stand-by server if there are any differences between them.</p>
 442      *
 443      * @param categoryId category id of synchronous data
 444      * @param recvData recieve data from active server
 445      * @throws MessageView
 446      */
 447     protected Vector<UserData> compareUserData(Payload recvData,
 448                     Vector<UserData> sbyUserVec) throws MessageView {
 449         //      debug log(in method)
 450         if (debugUserLogger.isDebugEnabled()) {
 451             StringBuffer buf = new StringBuffer();
 452             buf
 453                             .append("L7SyncManager::compareUserData(Payload recvData, Vector<UserData> sbyUserVec) throws MessageView in ");
 454             buf.append("recvData= " + recvData.toString() + ", ");
 455             buf.append("sbyUserVec= " + sbyUserVec.toString());
 456             debugUserLogger.debug("11068 " + buf.toString());
 457         }
 458
 459         if (SyncCategoryIdSet.USERDATA_ID != recvData.categoryId) {
 460             throw new MessageView(40021, LogCategorySet.SYNC_SYNC_USER_DATA,
 461                             Message.SYNC_INVALID_CATEGORY_ID);
 462         }
 463
 464         Vector<UserData> actUserVec = recvData.getUserData();
 465
 466         if (actUserVec.size() != sbyUserVec.size() || !actUserVec.equals(sbyUserVec)) {
 467             userLogger.info("21016 " + Message.SYNC_DIFFERENT_DATA + " : "
 468                             + SyncCategoryIdSet.toCategoryName(recvData.categoryId));
 469
 470             // debug log(out method)
 471             if (debugUserLogger.isDebugEnabled()) {
 472                 StringBuffer buf = new StringBuffer();
 473                 buf
 474                                 .append("L7SyncManager::compareUserData(Payload recvData, Vector<UserData> sbyUserVec) throws MessageView out ");
 475                 buf.append("return= " + actUserVec.toString());
 476                 debugUserLogger.debug("11069 " + buf.toString());
 477             }
 478
 479             return actUserVec;
 480         } else {
 481             userLogger.info("21017 " + Message.SYNC_SAME_DATA + " : "
 482                             + SyncCategoryIdSet.toCategoryName(recvData.categoryId));
 483
 484             // debug log(out method)
 485             if (debugUserLogger.isDebugEnabled()) {
 486                 StringBuffer buf = new StringBuffer();
 487                 buf
 488                                 .append("L7SyncManager::compareUserData(Payload recvData, Vector<UserData> sbyUserVec) throws MessageView out ");
 489                 buf.append("return= null");
 490                 debugUserLogger.debug("11070 " + buf.toString());
 491             }
 492
 493             return null;
 494         }
 495     }
 496
 497     /**
 498      * <p> Compares L7vsConfData settings in active server with those in stand-by server. Updates L7vsConfData in stand-by server if there are any differences between them.</p>
 499      *
 500      * @param categoryId category ID of synchronous data
 501      * @param recvData recieve data from active server
 502      * @throws MessageView
 503      */
 504     protected L7vsConfData compareL7vsConfData(Payload recvData,
 505                     L7vsConfData sbyL7vsdConfData) throws MessageView {
 506         //      debug log(in method)
 507         if (debugL7vsdConfLogger.isDebugEnabled()) {
 508             StringBuffer buf = new StringBuffer();
 509             buf
 510                             .append("L7SyncManager::compareL7vsConfData(Payload recvData, L7vsConfData sbyL7vsdConfData) throws MessageView in ");
 511             buf.append("recvData= " + recvData.toString() + ", ");
 512             buf.append("sbyL7vsdConfData= " + sbyL7vsdConfData.toString());
 513             debugL7vsdConfLogger.debug("11071 " + buf.toString());
 514         }
 515
 516         L7vsConfData actL7vsdConfData = recvData.getL7vsdConfData();
 517         boolean needSync = false;
 518         L7vsConfController confController = new L7vsConfController();
 519
 520         switch (recvData.categoryId) {
 521         case SyncCategoryIdSet.L7VSD_LOG_ID:
 522             needSync = compareLogSettings(actL7vsdConfData.logger.lbLog,
 523                             sbyL7vsdConfData.logger.lbLog);
 524             if (needSync) {
 525                 sbyL7vsdConfData.logger.lbLog = actL7vsdConfData.logger.lbLog;
 526             }
 527             break;
 528
 529         case SyncCategoryIdSet.ADM_LOG_ID:
 530             needSync = compareLogSettings(actL7vsdConfData.logger.admLog,
 531                             sbyL7vsdConfData.logger.admLog);
 532             if (needSync) {
 533                 sbyL7vsdConfData.logger.admLog = actL7vsdConfData.logger.admLog;
 534             }
 535             break;
 536
 537         case SyncCategoryIdSet.SNMP_LOG_ID:
 538             needSync = compareLogSettings(actL7vsdConfData.logger.snmpLog,
 539                             sbyL7vsdConfData.logger.snmpLog);
 540             if (needSync) {
 541                 sbyL7vsdConfData.logger.snmpLog = actL7vsdConfData.logger.snmpLog;
 542             }
 543             break;
 544
 545         case SyncCategoryIdSet.LOG_ALL_ID:
 546             boolean lbLogFlg = compareLogSettings(actL7vsdConfData.logger.lbLog,
 547                             sbyL7vsdConfData.logger.lbLog);
 548             boolean admLogFlg = compareLogSettings(actL7vsdConfData.logger.admLog,
 549                             sbyL7vsdConfData.logger.admLog);
 550             boolean snmpLogFlg = compareLogSettings(actL7vsdConfData.logger.snmpLog,
 551                             sbyL7vsdConfData.logger.snmpLog);
 552
 553             needSync = lbLogFlg || admLogFlg || snmpLogFlg;
 554
 555             if (needSync) {
 556                 sbyL7vsdConfData.logger.lbLog = actL7vsdConfData.logger.lbLog;
 557                 sbyL7vsdConfData.logger.admLog = actL7vsdConfData.logger.admLog;
 558                 sbyL7vsdConfData.logger.snmpLog = actL7vsdConfData.logger.snmpLog;
 559             }
 560             break;
 561
 562         case SyncCategoryIdSet.REPLICATION_INFO_ID:
 563             if (actL7vsdConfData.replicationInterval != sbyL7vsdConfData.replicationInterval) {
 564                 logger.info("21018 " + Message.SYNC_DIFFERENT_DATA + ": Replication");
 565                 sbyL7vsdConfData.replicationInterval = actL7vsdConfData.replicationInterval;
 566                 needSync = true;
 567             }
 568             break;
 569
 570         case SyncCategoryIdSet.SNMP_INFO_ID:
 571             if (actL7vsdConfData.snmpInterval != sbyL7vsdConfData.snmpInterval) {
 572                 logger.info("21019 " + Message.SYNC_DIFFERENT_DATA + ": snmpInterval");
 573                 sbyL7vsdConfData.snmpInterval = actL7vsdConfData.snmpInterval;
 574                 needSync = true;
 575             }
 576             break;
 577
 578         case SyncCategoryIdSet.ADM_INFO_ID:
 579             if (actL7vsdConfData.admCmdInterval != sbyL7vsdConfData.admCmdInterval) {
 580                 logger.info("21020 " + Message.SYNC_DIFFERENT_DATA + ": admCmdInterval");
 581                 sbyL7vsdConfData.admCmdInterval = actL7vsdConfData.admCmdInterval;
 582                 needSync = true;
 583             }
 584             if (actL7vsdConfData.admCmdCount != sbyL7vsdConfData.admCmdCount) {
 585                 logger.info("21021 " + Message.SYNC_DIFFERENT_DATA + ": admCmdCount");
 586                 sbyL7vsdConfData.admCmdCount = actL7vsdConfData.admCmdCount;
 587                 needSync = true;
 588             }
 589             if (actL7vsdConfData.admConInterval != sbyL7vsdConfData.admConInterval) {
 590                 logger.info("21022 " + Message.SYNC_DIFFERENT_DATA + ": admConInterval");
 591                 sbyL7vsdConfData.admConInterval = actL7vsdConfData.admConInterval;
 592                 needSync = true;
 593             }
 594             if (actL7vsdConfData.admConCount != sbyL7vsdConfData.admConCount) {
 595                 logger.info("21023 " + Message.SYNC_DIFFERENT_DATA + ": admConCount");
 596                 sbyL7vsdConfData.admConCount = actL7vsdConfData.admConCount;
 597                 needSync = true;
 598             }
 599             break;
 600
 601         default:
 602             l7vsdConfLogger.error("41015 " + Message.SYNC_INVALID_CATEGORY_ID);
 603             throw new MessageView(40022, LogCategorySet.SYNC_SYNC_L7VSDCONF_DATA,
 604                             Message.SYNC_INVALID_CATEGORY_ID);
 605         }
 606
 607         if (!needSync) {
 608             l7vsdConfLogger.info("21024 " + Message.SYNC_SAME_DATA + " : "
 609                             + SyncCategoryIdSet.toCategoryName(recvData.categoryId));
 610             if (debugL7vsdConfLogger.isDebugEnabled()) {
 611                 StringBuffer buf = new StringBuffer();
 612                 buf
 613                                 .append("L7SyncManager::compareL7vsConfData(Payload recvData, L7vsConfData sbyL7vsdConfData) throws MessageView out ");
 614                 buf.append("return= null");
 615                 debugL7vsdConfLogger.debug("11072 " + buf.toString());
 616             }
 617             return null;
 618
 619         } else {
 620             //          debug log(out method)
 621             if (debugL7vsdConfLogger.isDebugEnabled()) {
 622                 StringBuffer buf = new StringBuffer();
 623                 buf
 624                                 .append("L7SyncManager::compareL7vsConfData(Payload recvData, L7vsConfData sbyL7vsdConfData) throws MessageView out ");
 625                 buf.append("return= " + sbyL7vsdConfData.toString());
 626                 debugL7vsdConfLogger.debug("11073 " + buf.toString());
 627             }
 628
 629             return sbyL7vsdConfData;
 630         }
 631     }
 632
 633     /**
 634      * <p> Gets synchronous data class from category ID.</p>
 635      *
 636      * @param categoryId category ID of synchronous data
 637      * @return data class name of synchronous data
 638      * @throws MessageView
 639      */
 640     protected SyncDataType getDataTypeFromId(int categoryId) throws MessageView {
 641         //      debug log(in method)
 642         if (debugLogger.isDebugEnabled()) {
 643             StringBuffer buf = new StringBuffer();
 644             buf
 645                             .append("L7SyncManager::getDataTypeFromId(int categoryId) throws MessageView in ");
 646             buf.append("categoryId=" + categoryId);
 647             debugLogger.debug("11074 " + buf.toString());
 648         }
 649
 650         switch (categoryId) {
 651         case SyncCategoryIdSet.MONITOR_ID:
 652         case SyncCategoryIdSet.SERVICE_ID:
 653             //          debug log(out method)
 654             if (debugLogger.isDebugEnabled()) {
 655                 StringBuffer buf = new StringBuffer();
 656                 buf
 657                                 .append("L7SyncManager::getDataTypeFromId(int categoryId) throws MessageView out ");
 658                 buf.append("return= SyncDataType.DIRECTORDATA");
 659                 debugLogger.debug("11075 " + buf.toString());
 660             }
 661             return SyncDataType.DIRECTORDATA;
 662
 663         case SyncCategoryIdSet.L7VSD_LOG_ID:
 664         case SyncCategoryIdSet.ADM_LOG_ID:
 665         case SyncCategoryIdSet.SNMP_LOG_ID:
 666         case SyncCategoryIdSet.REPLICATION_INFO_ID:
 667         case SyncCategoryIdSet.ADM_INFO_ID:
 668         case SyncCategoryIdSet.SNMP_INFO_ID:
 669         case SyncCategoryIdSet.LOG_ALL_ID:
 670             //          debug log(out method)
 671             if (debugLogger.isDebugEnabled()) {
 672                 StringBuffer buf = new StringBuffer();
 673                 buf
 674                                 .append("L7SyncManager::getDataTypeFromId(int categoryId) throws MessageView out ");
 675                 buf.append("return= SyncDataType.L7VSCONFDATA");
 676                 debugLogger.debug("11076 " + buf.toString());
 677             }
 678             return SyncDataType.L7VSCONFDATA;
 679
 680         case SyncCategoryIdSet.USERDATA_ID:
 681             //          debug log(out method)
 682             if (debugLogger.isDebugEnabled()) {
 683                 StringBuffer buf = new StringBuffer();
 684                 buf
 685                                 .append("L7SyncManager::getDataTypeFromId(int categoryId) throws MessageView out ");
 686                 buf.append("return= SyncDataType.USERDATA");
 687                 debugLogger.debug("11077 " + buf.toString());
 688             }
 689             return SyncDataType.USERDATA;
 690
 691         default:
 692             throw new MessageView(40023, LogCategorySet.SYNC_SYNC,
 693                             Message.SYNC_INVALID_CATEGORY_ID);
 694         }
 695     }
 696
 697     /**
 698      * <p> Compares log settings in active server with those in stand-by server. </p>
 699      *
 700      * @param actLogger LogSet of active server
 701      * @param sbyLogger LogSet of stand-by server
 702      * @return sync flag
 703      */
 704     protected boolean compareLogSettings(LogSet actLogger, LogSet sbyLogger) {
 705         //      debug log(in method)
 706         if (debugL7vsdConfLogger.isDebugEnabled()) {
 707             StringBuffer buf = new StringBuffer();
 708             buf
 709                             .append("L7SyncManager::compareLogSettings(LogSet actLogger, LogSet sbyLogger) in ");
 710             buf.append("actLogger= " + actLogger.toString() + ", ");
 711             buf.append("sbyLogger= " + sbyLogger.toString());
 712             debugL7vsdConfLogger.debug("11078 " + buf.toString());
 713         }
 714
 715         boolean syncFlag = false;
 716         if (!actLogger.logLevel.equals(sbyLogger.logLevel)) {
 717             l7vsdConfLogger.info("21025 " + Message.SYNC_DIFFERENT_DATA + " : LogLevel ");
 718             syncFlag = true;
 719         }
 720         if (!actLogger.maxFileSize.equals(sbyLogger.maxFileSize)) {
 721             l7vsdConfLogger.info("21026 " + Message.SYNC_DIFFERENT_DATA + " : maxFileSize ");
 722             syncFlag = true;
 723         }
 724         if (actLogger.maxBackupIndex != sbyLogger.maxBackupIndex) {
 725             l7vsdConfLogger.info("21027 " + Message.SYNC_DIFFERENT_DATA + " : maxBackupIndex ");
 726             syncFlag = true;
 727         }
 728         if (!actLogger.fileName.equals(sbyLogger.fileName)) {
 729             l7vsdConfLogger.info("21028 " + Message.SYNC_DIFFERENT_DATA + " : fileName ");
 730             syncFlag = true;
 731         }
 732         if (!actLogger.rotation.equals(sbyLogger.rotation)) {
 733             l7vsdConfLogger.info("21029 " + Message.SYNC_DIFFERENT_DATA + " : rotation ");
 734             syncFlag = true;
 735         }
 736         //      debug log(out method)
 737         if (debugL7vsdConfLogger.isDebugEnabled()) {
 738             StringBuffer buf = new StringBuffer();
 739             buf
 740                             .append("L7SyncManager::compareLogSettings(LogSet actLogger, LogSet sbyLogger) out ");
 741             buf.append("return= " + syncFlag);
 742             debugL7vsdConfLogger.debug("11079 " + buf.toString());
 743         }
 744
 745         return syncFlag;
 746     }
 747 }