src/src/org/ultramonkey/l7/view/CommandExecuter.java

   1 package org.ultramonkey.l7.view;
   2
   3 import java.io.Serializable;
   4 import java.util.HashSet;
   5
   6 import javax.servlet.http.HttpSession;
   7
   8 import org.ultramonkey.l7.controller.*;
   9 import org.ultramonkey.l7.model.*;
  10
  11 public class CommandExecuter extends Thread implements Serializable {
  12         static final long serialVersionUID = 1L;
  13
  14         ExecuteMode mode;
  15
  16         Object DataClass;
  17
  18         Object OrgDataClass;
  19
  20         Object NewDataClass;
  21
  22         HttpSession session;
  23
  24         public CommandExecuter(HttpSession session) {
  25                 this.session = session;
  26                 this.mode = null;
  27                 this.DataClass = null;
  28                 this.OrgDataClass = null;
  29                 this.NewDataClass = null;
  30
  31         }
  32
  33         private void setThreadStatus(MessageView mv) {
  34                 session.setAttribute(SessionKeys.COMMAND_MESSAGE, mv);
  35         }
  36
  37         private void setThreadStatus(String st) {
  38                 session.setAttribute(SessionKeys.THREAD_STATUS, st);
  39         }
  40
  41         private void setThreadStatus(String st, String mes) {
  42                 session.setAttribute(SessionKeys.THREAD_STATUS, st);
  43         }
  44
  45         public void setExecute(ExecuteMode mode, DirectorData DataClass)
  46                         throws IllegalArgumentException {
  47                 if (DataClass == null) {
  48                         throw (new IllegalArgumentException(
  49                                         "Exception DirectorData is null."));
  50                 }
  51                 this.mode = mode;
  52                 this.DataClass = DataClass;
  53         }
  54
  55         public void setExecute(ExecuteMode mode, VirtualSetting DataClass)
  56                         throws IllegalArgumentException {
  57                 if (DataClass == null) {
  58                         throw (new IllegalArgumentException(
  59                                         "Exception VirtualSettingData is null."));
  60                 }
  61                 this.mode = mode;
  62                 this.DataClass = DataClass;
  63
  64         }
  65
  66         public void setExecute(ExecuteMode mode, VirtualSetting OrgDataClass,
  67                         VirtualSetting NewDataClass) throws IllegalArgumentException {
  68                 if (OrgDataClass == null || NewDataClass == null) {
  69                         throw (new IllegalArgumentException(
  70                                         "Exception VirtualSettingData is null."));
  71                 }
  72
  73                 this.mode = mode;
  74                 this.OrgDataClass = OrgDataClass;
  75                 this.NewDataClass = NewDataClass;
  76         }
  77
  78         public void setExecute(ExecuteMode mode) {
  79                 this.mode = mode;
  80         }
  81
  82         public void setExecute(ExecuteMode mode, ReplicationData DataClass) {
  83                 if (DataClass == null) {
  84                         throw (new IllegalArgumentException(
  85                                         "Exception ReplicationData is null."));
  86                 }
  87                 this.mode = mode;
  88                 this.DataClass = DataClass;
  89         }
  90
  91         public void setExecute(ExecuteMode mode, LogData DataClass) {
  92                 if (DataClass == null) {
  93                         throw (new IllegalArgumentException("Exception LogDeta is null."));
  94                 }
  95                 this.mode = mode;
  96                 this.DataClass = DataClass;
  97
  98         }
  99
 100         public void setExecute(ExecuteMode mode, SnmpAgentData DataClass) {
 101                 if (DataClass == null) {
 102                         throw (new IllegalArgumentException(
 103                                         "Exception SnmpAgentData is null."));
 104                 }
 105                 this.mode = mode;
 106                 this.DataClass = DataClass;
 107
 108         }
 109
 110         public void setExecute(ExecuteMode mode, HashSet DataClass) {
 111                 if (DataClass == null) {
 112                         throw (new IllegalArgumentException(
 113                                         "Exception categoryList is null."));
 114                 }
 115                 this.mode = mode;
 116                 this.DataClass = DataClass;
 117
 118         }
 119
 120         private boolean vsRemove(DirectorData dd, VirtualSetting vs) {
 121                 int i;
 122                 for (i = 0; i < dd.virtualSettings.size(); i++) {
 123                         if (vs.isSameService(dd.virtualSettings.elementAt(i))) {
 124                                 dd.virtualSettings.remove(i);
 125                                 return true;
 126                         }
 127                 }
 128                 return false;
 129         }
 130
 131         private boolean vsRemove(L7vsAdmData ad, VirtualSetting vs) {
 132                 int i;
 133                 for (i = 0; i < ad.virtualSettings.size(); i++) {
 134                         if (vs.isSameService(ad.virtualSettings.elementAt(i))) {
 135                                 return true;
 136                         }
 137                 }
 138                 return false;
 139         }
 140
 141         public void run() {
 142                 boolean result = false;
 143                 boolean sameVs = false;
 144                 String message = "";
 145                 int errno = 0;
 146                 HashSet cset = new HashSet();
 147                 DirectorData dd;
 148                 L7vsAdmData ad;
 149                 setThreadStatus(SessionKeys.THREAD_RUNNING);
 150                 L7guiFramework framework = new L7guiFramework();
 151                 L7vsConfController confController = new L7vsConfController();
 152                 switch (this.mode) {
 153                 case DIRECTOR_SAVE:
 154                         String syntax = framework.checkDirectorData((DirectorData) this.DataClass);
 155                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 156                                 errno = 41099;
 157                                 if (syntax == null)
 158                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 159                                 else {
 160                                         String[] error = syntax.split("at line \\d+: ", 2);
 161                                         if (error.length == 2)
 162                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 163                                         else
 164                                                 message = Message.DIRECTOR_SYNTAX_ERROR + " \"" + syntax + "\"";
 165                                 }
 166                                 result = false;
 167                                 break;
 168                         }
 169                         else if (!(result = framework
 170                                         .setDirectorData((DirectorData) this.DataClass))) {
 171                                 errno = 41100;
 172                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 173                                 break;
 174                         }
 175                         errno = 21049;
 176                         message = Message.DIRECTOR_SAVE;
 177                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 178                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 179                         session.setAttribute(SessionKeys.MONITOR_SYNC_STATE, SessionKeys.NO_SYNC);
 180                         break;
 181
 182                 case DIRECTOR_SAVESYNC:
 183                         syntax = framework.checkDirectorData((DirectorData) this.DataClass);
 184                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 185                                 errno = 41101;
 186                                 if (syntax == null)
 187                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 188                                 else {
 189                                         String[] error = syntax.split("at line \\d+: ", 2);
 190                                         if (error.length == 2)
 191                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 192                                         else
 193                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 194                                 }
 195                                 result = false;
 196                                 break;
 197                         }
 198                         else if (!(result = framework
 199                                         .setDirectorData((DirectorData) this.DataClass))) {
 200                                 errno = 41102;
 201                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 202                                 break;
 203                         }
 204                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 205                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 206                         session.setAttribute(SessionKeys.MONITOR_SYNC_STATE, SessionKeys.NO_SYNC);
 207                         cset.add(SyncCategoryIdSet.MONITOR_ID);
 208                         if (!(result = framework.syncExecute(cset))) {
 209                                 errno = 41103;
 210                                 message = Message.SYNC_ERROR_L7DIRECTORD;
 211                                 break;
 212                         }
 213                         errno = 21050;
 214                         message = Message.DIRECTOR_SAVESYNC;
 215                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.SYNC);
 216                         session.setAttribute(SessionKeys.MONITOR_SYNC_STATE, SessionKeys.SYNC);
 217                         break;
 218
 219                 case VS_ADD_APPLY: //
 220                         if (!(result = framework
 221                                         .addVirtualSetting((VirtualSetting) this.DataClass))) {
 222                                 errno = 41104;
 223                                 message = Message.L7VSADM_ERROR;
 224                                 break;
 225                         }
 226                         errno = 21051;
 227                         message = Message.VS_ADD_APPLY;
 228                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 229                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 230                         break;
 231
 232                 case VS_ADD_SAVE: //
 233                         // SAVE
 234                         if ((dd = framework.getDirectorData()) == null) {
 235                                 errno = 41105;
 236                                 message = Message.DIRECTOR_DATA_ERROR;
 237                                 result = false;
 238                                 break;
 239                         }
 240                         for (VirtualSetting exist : dd.virtualSettings) {
 241                                 if (exist.isSameService((VirtualSetting) DataClass)) {
 242                                         sameVs = true;
 243                                         break;
 244                                 }
 245                         }
 246                         if (sameVs == true) {
 247                                 errno = 41106;
 248                                 message = Message.VIRTUAL_SERVER_EXIST;
 249                                 result = false;
 250                                 break;
 251                         }
 252                         dd.virtualSettings.add((VirtualSetting) this.DataClass);
 253                         syntax = framework.checkDirectorData(dd);
 254                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 255                                 errno = 41107;
 256                                 if (syntax == null)
 257                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 258                                 else {
 259                                         String[] error = syntax.split("at line \\d+: ", 2);
 260                                         if (error.length == 2)
 261                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 262                                         else
 263                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 264                                 }
 265                                 result = false;
 266                                 break;
 267                         }
 268                         else if (!(result = framework.setDirectorData(dd))) {
 269                                 errno = 41108;
 270                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 271                                 break;
 272                         }
 273                         errno = 21052;
 274                         message = Message.VS_ADD_SAVE;
 275                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 276                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 277                         break;
 278
 279                 case VS_ADD_SAVESYNC: //
 280                         // SAVE
 281                         if ((dd = framework.getDirectorData()) == null) {
 282                                 errno = 41109;
 283                                 message = Message.DIRECTOR_DATA_ERROR;
 284                                 result = false;
 285                                 break;
 286                         }
 287                         for (VirtualSetting exist : dd.virtualSettings) {
 288                                 if (exist.isSameService((VirtualSetting) DataClass)) {
 289                                         sameVs = true;
 290                                         break;
 291                                 }
 292                         }
 293                         if (sameVs == true) {
 294                                 errno = 41110;
 295                                 message = Message.VIRTUAL_SERVER_EXIST;
 296                                 result = false;
 297                                 break;
 298                         }
 299                         dd.virtualSettings.add((VirtualSetting) this.DataClass);
 300                         syntax = framework.checkDirectorData(dd);
 301                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 302                                 errno = 41111;
 303                                 if (syntax == null)
 304                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 305                                 else {
 306                                         String[] error = syntax.split("at line \\d+: ", 2);
 307                                         if (error.length == 2)
 308                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 309                                         else
 310                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 311                                 }
 312                                 result = false;
 313                                 break;
 314                         }
 315                         else if (!(result = framework.setDirectorData(dd))) {
 316                                 errno = 41112;
 317                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 318                                 break;
 319                         }
 320                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 321                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 322                         // SYNC
 323                         cset.add(SyncCategoryIdSet.SERVICE_ID);
 324                         if (!(result = framework.syncExecute(cset))) {
 325                                 errno = 41113;
 326                                 message = Message.SYNC_ERROR_L7DIRECTORD;
 327                                 break;
 328                         }
 329                         errno = 21053;
 330                         message = Message.VS_ADD_SAVESYNC;
 331                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.SYNC);
 332                         break;
 333
 334                 case VS_REMOVE_APPLY: //
 335                         if (!(result = framework
 336                                         .delVirtualSetting((VirtualSetting) this.DataClass))) {
 337                                 errno = 41114;
 338                                 message = Message.L7VSADM_ERROR;
 339                                 break;
 340                         }
 341                         errno = 21054;
 342                         message = Message.VS_REMOVE_APPLY;
 343                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 344                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 345                         break;
 346
 347                 case VS_REMOVE_SAVE: //
 348                         // SAVE
 349                         if ((dd = framework.getDirectorData()) == null) {
 350                                 errno = 41115;
 351                                 message = Message.DIRECTOR_DATA_ERROR;
 352                                 result = false;
 353                                 break;
 354                         }
 355                         if ((ad = framework.getAdmData()) == null) {
 356                                 errno = 41116;
 357                                 message = Message.L7VSADM_ERROR;
 358                                 result = false;
 359                                 break;
 360                         }
 361                         result = this.vsRemove(dd, (VirtualSetting) this.DataClass);
 362                         syntax = framework.checkDirectorData(dd);
 363                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 364                                 errno = 41117;
 365                                 if (syntax == null)
 366                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 367                                 else {
 368                                         String[] error = syntax.split("at line \\d+: ", 2);
 369                                         if (error.length == 2)
 370                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 371                                         else
 372                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 373                                 }
 374                                 result = false;
 375                                 break;
 376                         }
 377                         if (result == false) {
 378                                 if(!(result = this.vsRemove(ad, (VirtualSetting) this.DataClass))) {
 379                                         errno = 41118;
 380                                         message = Message.NO_VS;
 381                                         break;
 382                                 } else if (!(result = framework.delVirtualSetting((VirtualSetting) this.DataClass))) {
 383                                         errno = 41119;
 384                                         message = Message.L7VSADM_ERROR;
 385                                         break;
 386                                 }
 387                                 session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 388                                 session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 389                         }
 390                         if (!(result = framework.setDirectorData(dd))) {
 391                                 errno = 41120;
 392                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 393                                 break;
 394                         }
 395                         errno = 21055;
 396                         message = Message.VS_REMOVE_SAVE;
 397                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 398                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 399                         break;
 400
 401                 case VS_REMOVE_SAVESYNC: //
 402                         // SAVE
 403                         if ((dd = framework.getDirectorData()) == null) {
 404                                 errno = 41121;
 405                                 message = Message.DIRECTOR_DATA_ERROR;
 406                                 result = false;
 407                                 break;
 408                         }
 409                         if ((ad = framework.getAdmData()) == null) {
 410                                 errno = 41122;
 411                                 message = Message.L7VSADM_ERROR;
 412                                 result = false;
 413                                 break;
 414                         }
 415                         result = this.vsRemove(dd, (VirtualSetting) this.DataClass);
 416                         syntax = framework.checkDirectorData(dd);
 417                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 418                                 errno = 41123;
 419                                 if (syntax == null)
 420                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 421                                 else {
 422                                         String[] error = syntax.split("at line \\d+: ", 2);
 423                                         if (error.length == 2)
 424                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 425                                         else
 426                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 427                                 }
 428                                 result = false;
 429                                 break;
 430                         }
 431                         if (result == false) {
 432                                 if(!(result = this.vsRemove(ad, (VirtualSetting) this.DataClass))) {
 433                                         errno = 41124;
 434                                         message = Message.NO_VS;
 435                                         break;
 436                                 } else if (!(result = framework.delVirtualSetting((VirtualSetting) this.DataClass))) {
 437                                         errno = 41125;
 438                                         message = Message.L7VSADM_ERROR;
 439                                         break;
 440                                 }
 441                                 session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 442                                 session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 443                         }
 444                         if (!(result = framework.setDirectorData(dd))) {
 445                                 errno = 41126;
 446                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 447                                 break;
 448                         }
 449                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 450                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 451
 452                         // SYNC
 453                         cset.add(SyncCategoryIdSet.SERVICE_ID);
 454                         if (!(result = framework.syncExecute(cset))) {
 455                                 errno = 41127;
 456                                 message = Message.SYNC_ERROR_L7DIRECTORD;
 457                                 break;
 458                         }
 459                         errno = 21056;
 460                         message = Message.VS_REMOVE_SAVESYNC;
 461                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.SYNC);
 462                         break;
 463
 464                 case VS_MODIFY_APPLY: //
 465                         if (!(result = framework
 466                                         .delVirtualSetting((VirtualSetting) this.OrgDataClass))) {
 467                                 errno = 41128;
 468                                 message = Message.L7VSADM_ERROR;
 469                                 break;
 470                         }
 471                         if (!(result = framework
 472                                         .addVirtualSetting((VirtualSetting) this.NewDataClass))) {
 473                                 errno = 41129;
 474                                 message = Message.L7VSADM_ERROR;
 475                                 break;
 476                         }
 477                         errno = 21057;
 478                         message = Message.VS_MODIFY_APPLY;
 479                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 480                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 481                         break;
 482
 483                 case VS_MODIFY_SAVE: //
 484                         if ((dd = framework.getDirectorData()) == null) {
 485                                 errno = 41130;
 486                                 message = Message.DIRECTOR_DATA_ERROR;
 487                                 result = false;
 488                                 break;
 489                         }
 490                         if ((ad = framework.getAdmData()) == null) {
 491                                 errno = 41131;
 492                                 message = Message.L7VSADM_ERROR;
 493                                 result = false;
 494                                 break;
 495                         }
 496                         result = this.vsRemove(dd, (VirtualSetting) this.OrgDataClass);
 497                         for (VirtualSetting exist : dd.virtualSettings) {
 498                                 if (exist.isSameService((VirtualSetting) NewDataClass)) {
 499                                         sameVs = true;
 500                                         break;
 501                                 }
 502                         }
 503                         if (sameVs == true) {
 504                                 errno = 41132;
 505                                 message = Message.VIRTUAL_SERVER_EXIST;
 506                                 result = false;
 507                                 break;
 508                         }
 509                         dd.virtualSettings.add((VirtualSetting) this.NewDataClass);
 510                         syntax = framework.checkDirectorData(dd);
 511                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 512                                 errno = 41133;
 513                                 if (syntax == null)
 514                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 515                                 else {
 516                                         String[] error = syntax.split("at line \\d+: ", 2);
 517                                         if (error.length == 2)
 518                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 519                                         else
 520                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 521                                 }
 522                                 result = false;
 523                                 break;
 524                         }
 525                         if (result == false) {
 526                                 if(!(result = this.vsRemove(ad, (VirtualSetting) this.OrgDataClass))) {
 527                                         errno = 41134;
 528                                         message = Message.NO_VS;
 529                                         break;
 530                                 } else if (!(result = framework.delVirtualSetting((VirtualSetting) this.OrgDataClass))) {
 531                                         errno = 41135;
 532                                         message = Message.L7VSADM_ERROR;
 533                                         break;
 534                                 }
 535                                 session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 536                                 session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 537                         }
 538                         if (!(result = framework.setDirectorData(dd))) {
 539                                 errno = 41136;
 540                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 541                                 break;
 542                         }
 543                         errno = 21058;
 544                         message = Message.VS_MODIFY_SAVE;
 545                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 546                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 547                         break;
 548
 549                 case VS_MODIFY_SAVESYNC: //
 550                         if ((dd = framework.getDirectorData()) == null) {
 551                                 errno = 41137;
 552                                 message = Message.DIRECTOR_DATA_ERROR;
 553                                 result = false;
 554                                 break;
 555                         }
 556                         if ((ad = framework.getAdmData()) == null) {
 557                                 errno = 41138;
 558                                 message = Message.L7VSADM_ERROR;
 559                                 result = false;
 560                                 break;
 561                         }
 562                         result = this.vsRemove(dd, (VirtualSetting) this.OrgDataClass);
 563                         for (VirtualSetting exist : dd.virtualSettings) {
 564                                 if (exist.isSameService((VirtualSetting) NewDataClass)) {
 565                                         sameVs = true;
 566                                         break;
 567                                 }
 568                         }
 569                         if (sameVs == true) {
 570                                 errno = 41139;
 571                                 message = Message.VIRTUAL_SERVER_EXIST;
 572                                 result = false;
 573                                 break;
 574                         }
 575                         dd.virtualSettings.add((VirtualSetting) this.NewDataClass);
 576                         syntax = framework.checkDirectorData(dd);
 577                         if (syntax == null || !syntax.matches("^Syntax OK\n$")) {
 578                                 errno = 41140;
 579                                 if (syntax == null)
 580                                         message = Message.WRITE_ERROR_L7DIRECTORD;
 581                                 else {
 582                                         String[] error = syntax.split("at line \\d+: ", 2);
 583                                         if (error.length == 2)
 584                                                 message = Message.DIRECTOR_SYNTAX_ERROR + ": \"" + error[1] + "\"";
 585                                         else
 586                                                 message = Message.DIRECTOR_SYNTAX_ERROR + "\"" + syntax + "\"";
 587                                 }
 588                                 result = false;
 589                                 break;
 590                         }
 591                         if (result == false) {
 592                                 if(!(result = this.vsRemove(ad, (VirtualSetting) this.OrgDataClass))) {
 593                                         errno = 41141;
 594                                         message = Message.NO_VS;
 595                                         break;
 596                                 } else if (!(result = framework.delVirtualSetting((VirtualSetting) this.OrgDataClass))) {
 597                                         errno = 41142;
 598                                         message = Message.L7VSADM_ERROR;
 599                                         break;
 600                                 }
 601                                 session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.NO_SAVE);
 602                                 session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 603                         }
 604                         if (!(result = framework.setDirectorData(dd))) {
 605                                 errno = 41143;
 606                                 message = Message.WRITE_ERROR_L7DIRECTORD;
 607                                 break;
 608                         }
 609                         session.setAttribute(SessionKeys.VS_SAVE_STATE, SessionKeys.SAVE);
 610                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.NO_SYNC);
 611                         // SYNC
 612                         cset.add(SyncCategoryIdSet.SERVICE_ID);
 613                         if (!(result = framework.syncExecute(cset))) {
 614                                 errno = 41144;
 615                                 message = Message.SYNC_ERROR_L7DIRECTORD;
 616                                 break;
 617                         }
 618                         errno = 21059;
 619                         message = Message.VS_MODIFY_SAVESYNC;
 620                         session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.SYNC);
 621                         break;
 622
 623                 case CLUSTER_SWITCHORVER: //
 624                         if (!(result = framework.setClusterMode())) {
 625                                 errno = 41145;
 626                                 message = Message.CLUSTER_COMMAND_ERROR;
 627                         } else {
 628                                 errno = 21060;
 629                                 message = Message.CLUSTER_SWITCHORVER;
 630                         }
 631                         break;
 632
 633                 case REP_MASTER: //
 634                         if (!(result = framework
 635                                         .setReplicationMode(ReplicationStatus.MASTER))) {
 636                                 errno = 41146;
 637                                 message = Message.L7VSADM_ERROR;
 638                         } else {
 639                                 errno = 21061;
 640                                 message = Message.REP_MASTER;
 641                         }
 642                         break;
 643
 644                 case REP_MASTER_STOP: //
 645                         if (!(result = framework
 646                                         .setReplicationMode(ReplicationStatus.MASTER_STOP))) {
 647                                 errno = 41147;
 648                                 message = Message.L7VSADM_ERROR;
 649                         } else {
 650                                 errno = 21062;
 651                                 message = Message.REP_MASTER_STOP;
 652                         }
 653                         break;
 654
 655                 case REP_SLAVE: //
 656                         if (!(result = framework
 657                                         .setReplicationMode(ReplicationStatus.SLAVE))) {
 658                                 errno = 41148;
 659                                 message = Message.L7VSADM_ERROR;
 660                         } else {
 661                                 errno = 21063;
 662                                 message = Message.REP_SLAVE;
 663                         }
 664                         break;
 665
 666                 case REP_SLAVE_STOP: //
 667                         if (!(result = framework
 668                                         .setReplicationMode(ReplicationStatus.SLAVE_STOP))) {
 669                                 errno = 41149;
 670                                 message = Message.L7VSADM_ERROR;
 671                         } else {
 672                                 errno = 21064;
 673                                 message = Message.REP_SLAVE_STOP;
 674                         }
 675                         break;
 676
 677                 case REP_INFO_SAVE: //
 678                         if (!(result = framework
 679                                         .setReplicationData((ReplicationData) DataClass))) {
 680                                 errno = 41150;
 681                                 message = Message.WRITE_ERROR_L7VS;
 682                         } else {
 683                                 errno = 21065;
 684                                 message = Message.REP_INFO_SAVE;
 685                                 session.setAttribute(SessionKeys.REP_SYNC_STATE, SessionKeys.NO_SYNC);
 686                         }
 687                         break;
 688
 689                 case REP_INFO_SAVESYNC: //
 690                         if (result = framework
 691                                         .setReplicationData((ReplicationData) DataClass)) {
 692                                 session.setAttribute(SessionKeys.REP_SYNC_STATE, SessionKeys.NO_SYNC);
 693                                 // SYNC
 694                                 cset.add(SyncCategoryIdSet.REPLICATION_INFO_ID);
 695                                 if (!(result = framework.syncExecute(cset))) {
 696                                         errno = 41151;
 697                                         message = Message.SYNC_ERROR_L7VS;
 698                                 } else {
 699                                         errno = 21066;
 700                                         message = Message.REP_INFO_SAVESYNC;
 701                                         session.setAttribute(SessionKeys.REP_SYNC_STATE, SessionKeys.SYNC);
 702                                 }
 703                         } else {
 704                                 errno = 41152;
 705                                 message = Message.WRITE_ERROR_L7VS;
 706                         }
 707                         break;
 708
 709                 case REP_START://
 710                         if (!(result = framework.dumpReplicationData())) {
 711                                 errno = 41153;
 712                                 message = Message.L7VSADM_ERROR;
 713                         } else {
 714                                 errno = 21067;
 715                                 message = Message.REP_START;
 716                         }
 717                         break;
 718
 719                 case LOGLEVEL_CHANGE_APPLY:
 720                         LogData ld = (LogData) DataClass;
 721                         if (! (result = framework.setLogLevel(ld.lbLog.logLevel))) {
 722                                 errno = 41154;
 723                                 message = Message.L7VSADM_ERROR;
 724                         }
 725                         else if (! (result = framework.setLogLevel(ld.snmpLog.logLevel))) {
 726                                 errno = 41155;
 727                                 message = Message.L7VSADM_ERROR;
 728                         } else {
 729                                 errno = 21068;
 730                                 message = Message.LOGLEVEL_CHANGE_APPLY;
 731                                 session.setAttribute(SessionKeys.LOG_SAVE_STATE, SessionKeys.NO_SAVE);
 732                                 session.setAttribute(SessionKeys.LOG_SYNC_STATE, SessionKeys.NO_SYNC);
 733                         }
 734                         break;
 735
 736                 case LOGLEVEL_CHANGE_SAVE: //
 737                         try {
 738                                 L7vsConfData cf = confController.getConfData();
 739                                 cf.logger = (LogData) DataClass;
 740                                 if (! (result = framework.setL7vsConfData(cf))) {
 741                                         errno = 41156;
 742                                         message = Message.WRITE_ERROR_L7VS;
 743                                 } else if (! (result = framework.reloadAdmData(L7vsConfCategory.LOGGER))) {
 744                                         errno = 41157;
 745                                         message = Message.L7VSADM_ERROR;
 746                                 } else if (! (result = framework.reloadAdmData(L7vsConfCategory.SNMPAGENT))) {
 747                                         errno = 41158;
 748                                         message = Message.L7VSADM_ERROR;
 749                                 } else {
 750                                         errno = 21069;
 751                                         message = Message.LOGLEVEL_CHANGE_SAVE;
 752                                         session.setAttribute(SessionKeys.LOG_SAVE_STATE, SessionKeys.SAVE);
 753                                         session.setAttribute(SessionKeys.LOG_SYNC_STATE, SessionKeys.NO_SYNC);
 754                                 }
 755                         } catch (Exception e) {
 756                                 errno = 41159;
 757                                 message = Message.L7VS_CONF_DATA_ERROR;
 758                                 result = false;
 759                         }
 760                         break;
 761
 762                 case LOGLEVEL_CHANGE_SAVESYNC: //
 763                         try {
 764                                 L7vsConfData cf = confController.getConfData();
 765                                 cf.logger = (LogData) DataClass;
 766                                 if (! (result = framework.setL7vsConfData(cf))) {
 767                                         errno = 41160;
 768                                         message = Message.WRITE_ERROR_L7VS;
 769                                 } else if (! (result = framework.reloadAdmData(L7vsConfCategory.LOGGER))) {
 770                                         errno = 41161;
 771                                         message = Message.L7VSADM_ERROR;
 772                                 } else if (! (result = framework.reloadAdmData(L7vsConfCategory.SNMPAGENT))) {
 773                                         errno = 41162;
 774                                         message = Message.L7VSADM_ERROR;
 775                                 } else {
 776                                         session.setAttribute(SessionKeys.LOG_SAVE_STATE, SessionKeys.SAVE);
 777                                         session.setAttribute(SessionKeys.LOG_SYNC_STATE, SessionKeys.NO_SYNC);
 778                                         cset.add(SyncCategoryIdSet.LOG_ALL_ID);
 779                                         if (! (result = framework.syncExecute(cset))) {
 780                                                 errno = 41163;
 781                                                 message = Message.SYNC_ERROR_L7VS;
 782                                         } else {
 783                                                 errno = 21070;
 784                                                 message = Message.LOGLEVEL_CHANGE_SAVESYNC;
 785                                                 session.setAttribute(SessionKeys.LOG_SYNC_STATE, SessionKeys.SYNC);
 786                                         }
 787                                 }
 788                         } catch (Exception e) {
 789                                 errno = 41164;
 790                                 message = Message.L7VS_CONF_DATA_ERROR;
 791                                 result = false;
 792                         }
 793                         break;
 794
 795                 case SNMP_INFO_SAVE: //
 796                         if (!(result = framework
 797                                         .setSnmpAgentData((SnmpAgentData) DataClass))) {
 798                                 errno = 41165;
 799                                 message = Message.WRITE_ERROR_L7VS;
 800                         } else {
 801                                 errno = 21071;
 802                                 message = Message.SNMP_INFO_SAVE;
 803                                 session.setAttribute(SessionKeys.SNMP_SYNC_STATE, SessionKeys.NO_SYNC);
 804                         }
 805                         break;
 806
 807                 case SNMP_INFO_SAVESYNC: //
 808                         if (!(result = framework
 809                                         .setSnmpAgentData((SnmpAgentData) DataClass))) {
 810                                 errno = 41166;
 811                                 message = Message.WRITE_ERROR_L7VS;
 812                                 break;
 813                         }
 814                         session.setAttribute(SessionKeys.SNMP_SYNC_STATE, SessionKeys.NO_SYNC);
 815                         // SYNC
 816                         cset.add(SyncCategoryIdSet.SNMP_INFO_ID);
 817                         if (!(result = framework.syncExecute(cset))) {
 818                                 errno = 41167;
 819                                 message = Message.SYNC_ERROR_L7VS;
 820                         } else {
 821                                 errno = 21072;
 822                                 message = Message.SNMP_INFO_SAVESYNC;
 823                                 session.setAttribute(SessionKeys.SNMP_SYNC_STATE, SessionKeys.SYNC);
 824                         }
 825                         break;
 826
 827                 case SYNC: //
 828                         HashSet<Integer> syncSet = (HashSet<Integer>) DataClass;
 829                         if (!(result = framework.syncExecute(syncSet))) {
 830                                 errno = 41168;
 831                                 message = Message.SYNC_FAIL;
 832                         } else {
 833                                 errno = 21073;
 834                                 message = Message.SYNC;
 835                                 for (int i : syncSet) {
 836                                         switch(i) {
 837                                         case SyncCategoryIdSet.L7VSD_LOG_ID:
 838                                         case SyncCategoryIdSet.ADM_LOG_ID:
 839                                         case SyncCategoryIdSet.SNMP_LOG_ID:
 840                                         case SyncCategoryIdSet.LOG_ALL_ID:
 841                                                 session.setAttribute(SessionKeys.LOG_SYNC_STATE, SessionKeys.SYNC);
 842                                                 break;
 843                                         case SyncCategoryIdSet.REPLICATION_INFO_ID:
 844                                                 session.setAttribute(SessionKeys.REP_SYNC_STATE, SessionKeys.SYNC);
 845                                                 break;
 846                                         case SyncCategoryIdSet.SNMP_INFO_ID:
 847                                                 session.setAttribute(SessionKeys.SNMP_SYNC_STATE, SessionKeys.SYNC);
 848                                                 break;
 849                                         case SyncCategoryIdSet.MONITOR_ID:
 850                                                 session.setAttribute(SessionKeys.MONITOR_SYNC_STATE, SessionKeys.SYNC);
 851                                                 break;
 852                                         case SyncCategoryIdSet.SERVICE_ID:
 853                                                 session.setAttribute(SessionKeys.VS_SYNC_STATE, SessionKeys.SYNC);
 854                                                 break;
 855                                         case SyncCategoryIdSet.USERDATA_ID:
 856                                                 session.setAttribute(SessionKeys.GUI_SYNC_STATE, SessionKeys.SYNC);
 857                                         case SyncCategoryIdSet.ADM_INFO_ID:
 858                                         default:
 859                                         }
 860                                 }
 861                         }
 862                         break;
 863
 864                 default:
 865                         throw (new IllegalArgumentException("Illegal Parameter."));
 866                 }
 867                 MessageView mv = new MessageView();
 868                 mv.setCategory(LogCategorySet.GUI_IO_COMMAND);
 869                 mv.setMessage(message);
 870                 mv.setErrno(errno);
 871                 setThreadStatus(mv);
 872
 873                 if (result != true) {
 874                         setThreadStatus(SessionKeys.THREAD_FAIL);
 875                 } else {
 876                         setThreadStatus(SessionKeys.THREAD_SUCCESS);
 877                 }
 878                 return;
 879         }
 880 }