001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.admin.std.meta; 028 029 030 031 import java.util.Collection; 032 import java.util.SortedSet; 033 import org.opends.server.admin.AdministratorAction; 034 import org.opends.server.admin.client.AuthorizationException; 035 import org.opends.server.admin.client.CommunicationException; 036 import org.opends.server.admin.client.ConcurrentModificationException; 037 import org.opends.server.admin.client.ManagedObject; 038 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 039 import org.opends.server.admin.client.OperationRejectedException; 040 import org.opends.server.admin.DefaultBehaviorProvider; 041 import org.opends.server.admin.DefinedDefaultBehaviorProvider; 042 import org.opends.server.admin.DurationPropertyDefinition; 043 import org.opends.server.admin.IntegerPropertyDefinition; 044 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 045 import org.opends.server.admin.ManagedObjectDefinition; 046 import org.opends.server.admin.PropertyIsReadOnlyException; 047 import org.opends.server.admin.PropertyOption; 048 import org.opends.server.admin.PropertyProvider; 049 import org.opends.server.admin.server.ConfigurationChangeListener; 050 import org.opends.server.admin.server.ServerManagedObject; 051 import org.opends.server.admin.std.client.ReplicationServerCfgClient; 052 import org.opends.server.admin.std.server.ReplicationServerCfg; 053 import org.opends.server.admin.StringPropertyDefinition; 054 import org.opends.server.admin.Tag; 055 import org.opends.server.admin.TopCfgDefn; 056 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 057 import org.opends.server.types.DN; 058 059 060 061 /** 062 * An interface for querying the Replication Server managed object 063 * definition meta information. 064 * <p> 065 * Replication Servers publish updates to Directory Servers within a 066 * Replication Domain. 067 */ 068 public final class ReplicationServerCfgDefn extends ManagedObjectDefinition<ReplicationServerCfgClient, ReplicationServerCfg> { 069 070 // The singleton configuration definition instance. 071 private static final ReplicationServerCfgDefn INSTANCE = new ReplicationServerCfgDefn(); 072 073 074 075 // The "queue-size" property definition. 076 private static final IntegerPropertyDefinition PD_QUEUE_SIZE; 077 078 079 080 // The "replication-db-directory" property definition. 081 private static final StringPropertyDefinition PD_REPLICATION_DB_DIRECTORY; 082 083 084 085 // The "replication-port" property definition. 086 private static final IntegerPropertyDefinition PD_REPLICATION_PORT; 087 088 089 090 // The "replication-purge-delay" property definition. 091 private static final DurationPropertyDefinition PD_REPLICATION_PURGE_DELAY; 092 093 094 095 // The "replication-server" property definition. 096 private static final StringPropertyDefinition PD_REPLICATION_SERVER; 097 098 099 100 // The "replication-server-id" property definition. 101 private static final IntegerPropertyDefinition PD_REPLICATION_SERVER_ID; 102 103 104 105 // The "window-size" property definition. 106 private static final IntegerPropertyDefinition PD_WINDOW_SIZE; 107 108 109 110 // Build the "queue-size" property definition. 111 static { 112 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "queue-size"); 113 builder.setOption(PropertyOption.ADVANCED); 114 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "queue-size")); 115 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10000"); 116 builder.setDefaultBehaviorProvider(provider); 117 PD_QUEUE_SIZE = builder.getInstance(); 118 INSTANCE.registerPropertyDefinition(PD_QUEUE_SIZE); 119 } 120 121 122 123 // Build the "replication-db-directory" property definition. 124 static { 125 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "replication-db-directory"); 126 builder.setOption(PropertyOption.READ_ONLY); 127 builder.setOption(PropertyOption.MANDATORY); 128 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-db-directory")); 129 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("changelogDb"); 130 builder.setDefaultBehaviorProvider(provider); 131 PD_REPLICATION_DB_DIRECTORY = builder.getInstance(); 132 INSTANCE.registerPropertyDefinition(PD_REPLICATION_DB_DIRECTORY); 133 } 134 135 136 137 // Build the "replication-port" property definition. 138 static { 139 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "replication-port"); 140 builder.setOption(PropertyOption.MANDATORY); 141 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-port")); 142 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 143 builder.setUpperLimit(65535); 144 builder.setLowerLimit(1); 145 PD_REPLICATION_PORT = builder.getInstance(); 146 INSTANCE.registerPropertyDefinition(PD_REPLICATION_PORT); 147 } 148 149 150 151 // Build the "replication-purge-delay" property definition. 152 static { 153 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "replication-purge-delay"); 154 builder.setOption(PropertyOption.ADVANCED); 155 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-purge-delay")); 156 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("86400s"); 157 builder.setDefaultBehaviorProvider(provider); 158 builder.setAllowUnlimited(false); 159 builder.setBaseUnit("s"); 160 PD_REPLICATION_PURGE_DELAY = builder.getInstance(); 161 INSTANCE.registerPropertyDefinition(PD_REPLICATION_PURGE_DELAY); 162 } 163 164 165 166 // Build the "replication-server" property definition. 167 static { 168 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "replication-server"); 169 builder.setOption(PropertyOption.MULTI_VALUED); 170 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-server")); 171 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 172 builder.setPattern("^.+:[0-9]+$", "HOST:PORT"); 173 PD_REPLICATION_SERVER = builder.getInstance(); 174 INSTANCE.registerPropertyDefinition(PD_REPLICATION_SERVER); 175 } 176 177 178 179 // Build the "replication-server-id" property definition. 180 static { 181 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "replication-server-id"); 182 builder.setOption(PropertyOption.READ_ONLY); 183 builder.setOption(PropertyOption.MANDATORY); 184 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-server-id")); 185 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 186 builder.setUpperLimit(65535); 187 builder.setLowerLimit(1); 188 PD_REPLICATION_SERVER_ID = builder.getInstance(); 189 INSTANCE.registerPropertyDefinition(PD_REPLICATION_SERVER_ID); 190 } 191 192 193 194 // Build the "window-size" property definition. 195 static { 196 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "window-size"); 197 builder.setOption(PropertyOption.ADVANCED); 198 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "window-size")); 199 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("100"); 200 builder.setDefaultBehaviorProvider(provider); 201 PD_WINDOW_SIZE = builder.getInstance(); 202 INSTANCE.registerPropertyDefinition(PD_WINDOW_SIZE); 203 } 204 205 206 207 // Register the tags associated with this managed object definition. 208 static { 209 INSTANCE.registerTag(Tag.valueOf("replication")); 210 } 211 212 213 214 /** 215 * Get the Replication Server configuration definition singleton. 216 * 217 * @return Returns the Replication Server configuration definition 218 * singleton. 219 */ 220 public static ReplicationServerCfgDefn getInstance() { 221 return INSTANCE; 222 } 223 224 225 226 /** 227 * Private constructor. 228 */ 229 private ReplicationServerCfgDefn() { 230 super("replication-server", TopCfgDefn.getInstance()); 231 } 232 233 234 235 /** 236 * {@inheritDoc} 237 */ 238 public ReplicationServerCfgClient createClientConfiguration( 239 ManagedObject<? extends ReplicationServerCfgClient> impl) { 240 return new ReplicationServerCfgClientImpl(impl); 241 } 242 243 244 245 /** 246 * {@inheritDoc} 247 */ 248 public ReplicationServerCfg createServerConfiguration( 249 ServerManagedObject<? extends ReplicationServerCfg> impl) { 250 return new ReplicationServerCfgServerImpl(impl); 251 } 252 253 254 255 /** 256 * {@inheritDoc} 257 */ 258 public Class<ReplicationServerCfg> getServerConfigurationClass() { 259 return ReplicationServerCfg.class; 260 } 261 262 263 264 /** 265 * Get the "queue-size" property definition. 266 * <p> 267 * Specifies the number of changes that are kept in memory for each 268 * Directory Server in the Replication Domain. 269 * 270 * @return Returns the "queue-size" property definition. 271 */ 272 public IntegerPropertyDefinition getQueueSizePropertyDefinition() { 273 return PD_QUEUE_SIZE; 274 } 275 276 277 278 /** 279 * Get the "replication-db-directory" property definition. 280 * <p> 281 * The path where the Replication Server stores all persistent 282 * information. 283 * 284 * @return Returns the "replication-db-directory" property definition. 285 */ 286 public StringPropertyDefinition getReplicationDBDirectoryPropertyDefinition() { 287 return PD_REPLICATION_DB_DIRECTORY; 288 } 289 290 291 292 /** 293 * Get the "replication-port" property definition. 294 * <p> 295 * The port on which this Replication Server waits for connections 296 * from other Replication Servers or Directory Servers. 297 * 298 * @return Returns the "replication-port" property definition. 299 */ 300 public IntegerPropertyDefinition getReplicationPortPropertyDefinition() { 301 return PD_REPLICATION_PORT; 302 } 303 304 305 306 /** 307 * Get the "replication-purge-delay" property definition. 308 * <p> 309 * The time (in seconds) after which the Replication Server erases 310 * all persistent information. 311 * 312 * @return Returns the "replication-purge-delay" property definition. 313 */ 314 public DurationPropertyDefinition getReplicationPurgeDelayPropertyDefinition() { 315 return PD_REPLICATION_PURGE_DELAY; 316 } 317 318 319 320 /** 321 * Get the "replication-server" property definition. 322 * <p> 323 * Specifies the addresses of other Replication Servers to which 324 * this Replication Server tries to connect at startup time. 325 * <p> 326 * Addresses must be specified using the syntax: hostname:port 327 * 328 * @return Returns the "replication-server" property definition. 329 */ 330 public StringPropertyDefinition getReplicationServerPropertyDefinition() { 331 return PD_REPLICATION_SERVER; 332 } 333 334 335 336 /** 337 * Get the "replication-server-id" property definition. 338 * <p> 339 * Specifies a unique identifier for the Replication Server. 340 * <p> 341 * Each Replication Server must have a different server ID. 342 * 343 * @return Returns the "replication-server-id" property definition. 344 */ 345 public IntegerPropertyDefinition getReplicationServerIdPropertyDefinition() { 346 return PD_REPLICATION_SERVER_ID; 347 } 348 349 350 351 /** 352 * Get the "window-size" property definition. 353 * <p> 354 * Specifies the window size that the Replication Server uses when 355 * communicating with other Replication Servers. 356 * 357 * @return Returns the "window-size" property definition. 358 */ 359 public IntegerPropertyDefinition getWindowSizePropertyDefinition() { 360 return PD_WINDOW_SIZE; 361 } 362 363 364 365 /** 366 * Managed object client implementation. 367 */ 368 private static class ReplicationServerCfgClientImpl implements 369 ReplicationServerCfgClient { 370 371 // Private implementation. 372 private ManagedObject<? extends ReplicationServerCfgClient> impl; 373 374 375 376 // Private constructor. 377 private ReplicationServerCfgClientImpl( 378 ManagedObject<? extends ReplicationServerCfgClient> impl) { 379 this.impl = impl; 380 } 381 382 383 384 /** 385 * {@inheritDoc} 386 */ 387 public int getQueueSize() { 388 return impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition()); 389 } 390 391 392 393 /** 394 * {@inheritDoc} 395 */ 396 public void setQueueSize(Integer value) { 397 impl.setPropertyValue(INSTANCE.getQueueSizePropertyDefinition(), value); 398 } 399 400 401 402 /** 403 * {@inheritDoc} 404 */ 405 public String getReplicationDBDirectory() { 406 return impl.getPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition()); 407 } 408 409 410 411 /** 412 * {@inheritDoc} 413 */ 414 public void setReplicationDBDirectory(String value) throws PropertyIsReadOnlyException { 415 impl.setPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition(), value); 416 } 417 418 419 420 /** 421 * {@inheritDoc} 422 */ 423 public Integer getReplicationPort() { 424 return impl.getPropertyValue(INSTANCE.getReplicationPortPropertyDefinition()); 425 } 426 427 428 429 /** 430 * {@inheritDoc} 431 */ 432 public void setReplicationPort(int value) { 433 impl.setPropertyValue(INSTANCE.getReplicationPortPropertyDefinition(), value); 434 } 435 436 437 438 /** 439 * {@inheritDoc} 440 */ 441 public long getReplicationPurgeDelay() { 442 return impl.getPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition()); 443 } 444 445 446 447 /** 448 * {@inheritDoc} 449 */ 450 public void setReplicationPurgeDelay(Long value) { 451 impl.setPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition(), value); 452 } 453 454 455 456 /** 457 * {@inheritDoc} 458 */ 459 public SortedSet<String> getReplicationServer() { 460 return impl.getPropertyValues(INSTANCE.getReplicationServerPropertyDefinition()); 461 } 462 463 464 465 /** 466 * {@inheritDoc} 467 */ 468 public void setReplicationServer(Collection<String> values) { 469 impl.setPropertyValues(INSTANCE.getReplicationServerPropertyDefinition(), values); 470 } 471 472 473 474 /** 475 * {@inheritDoc} 476 */ 477 public Integer getReplicationServerId() { 478 return impl.getPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition()); 479 } 480 481 482 483 /** 484 * {@inheritDoc} 485 */ 486 public void setReplicationServerId(int value) throws PropertyIsReadOnlyException { 487 impl.setPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition(), value); 488 } 489 490 491 492 /** 493 * {@inheritDoc} 494 */ 495 public int getWindowSize() { 496 return impl.getPropertyValue(INSTANCE.getWindowSizePropertyDefinition()); 497 } 498 499 500 501 /** 502 * {@inheritDoc} 503 */ 504 public void setWindowSize(Integer value) { 505 impl.setPropertyValue(INSTANCE.getWindowSizePropertyDefinition(), value); 506 } 507 508 509 510 /** 511 * {@inheritDoc} 512 */ 513 public ManagedObjectDefinition<? extends ReplicationServerCfgClient, ? extends ReplicationServerCfg> definition() { 514 return INSTANCE; 515 } 516 517 518 519 /** 520 * {@inheritDoc} 521 */ 522 public PropertyProvider properties() { 523 return impl; 524 } 525 526 527 528 /** 529 * {@inheritDoc} 530 */ 531 public void commit() throws ManagedObjectAlreadyExistsException, 532 MissingMandatoryPropertiesException, ConcurrentModificationException, 533 OperationRejectedException, AuthorizationException, 534 CommunicationException { 535 impl.commit(); 536 } 537 538 } 539 540 541 542 /** 543 * Managed object server implementation. 544 */ 545 private static class ReplicationServerCfgServerImpl implements 546 ReplicationServerCfg { 547 548 // Private implementation. 549 private ServerManagedObject<? extends ReplicationServerCfg> impl; 550 551 // The value of the "queue-size" property. 552 private final int pQueueSize; 553 554 // The value of the "replication-db-directory" property. 555 private final String pReplicationDBDirectory; 556 557 // The value of the "replication-port" property. 558 private final int pReplicationPort; 559 560 // The value of the "replication-purge-delay" property. 561 private final long pReplicationPurgeDelay; 562 563 // The value of the "replication-server" property. 564 private final SortedSet<String> pReplicationServer; 565 566 // The value of the "replication-server-id" property. 567 private final int pReplicationServerId; 568 569 // The value of the "window-size" property. 570 private final int pWindowSize; 571 572 573 574 // Private constructor. 575 private ReplicationServerCfgServerImpl(ServerManagedObject<? extends ReplicationServerCfg> impl) { 576 this.impl = impl; 577 this.pQueueSize = impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition()); 578 this.pReplicationDBDirectory = impl.getPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition()); 579 this.pReplicationPort = impl.getPropertyValue(INSTANCE.getReplicationPortPropertyDefinition()); 580 this.pReplicationPurgeDelay = impl.getPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition()); 581 this.pReplicationServer = impl.getPropertyValues(INSTANCE.getReplicationServerPropertyDefinition()); 582 this.pReplicationServerId = impl.getPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition()); 583 this.pWindowSize = impl.getPropertyValue(INSTANCE.getWindowSizePropertyDefinition()); 584 } 585 586 587 588 /** 589 * {@inheritDoc} 590 */ 591 public void addChangeListener( 592 ConfigurationChangeListener<ReplicationServerCfg> listener) { 593 impl.registerChangeListener(listener); 594 } 595 596 597 598 /** 599 * {@inheritDoc} 600 */ 601 public void removeChangeListener( 602 ConfigurationChangeListener<ReplicationServerCfg> listener) { 603 impl.deregisterChangeListener(listener); 604 } 605 606 607 608 /** 609 * {@inheritDoc} 610 */ 611 public int getQueueSize() { 612 return pQueueSize; 613 } 614 615 616 617 /** 618 * {@inheritDoc} 619 */ 620 public String getReplicationDBDirectory() { 621 return pReplicationDBDirectory; 622 } 623 624 625 626 /** 627 * {@inheritDoc} 628 */ 629 public int getReplicationPort() { 630 return pReplicationPort; 631 } 632 633 634 635 /** 636 * {@inheritDoc} 637 */ 638 public long getReplicationPurgeDelay() { 639 return pReplicationPurgeDelay; 640 } 641 642 643 644 /** 645 * {@inheritDoc} 646 */ 647 public SortedSet<String> getReplicationServer() { 648 return pReplicationServer; 649 } 650 651 652 653 /** 654 * {@inheritDoc} 655 */ 656 public int getReplicationServerId() { 657 return pReplicationServerId; 658 } 659 660 661 662 /** 663 * {@inheritDoc} 664 */ 665 public int getWindowSize() { 666 return pWindowSize; 667 } 668 669 670 671 /** 672 * {@inheritDoc} 673 */ 674 public Class<? extends ReplicationServerCfg> configurationClass() { 675 return ReplicationServerCfg.class; 676 } 677 678 679 680 /** 681 * {@inheritDoc} 682 */ 683 public DN dn() { 684 return impl.getDN(); 685 } 686 687 } 688 }