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 org.opends.server.admin.AdministratorAction;
033 import org.opends.server.admin.BooleanPropertyDefinition;
034 import org.opends.server.admin.ClassPropertyDefinition;
035 import org.opends.server.admin.client.AuthorizationException;
036 import org.opends.server.admin.client.CommunicationException;
037 import org.opends.server.admin.client.ConcurrentModificationException;
038 import org.opends.server.admin.client.IllegalManagedObjectNameException;
039 import org.opends.server.admin.client.ManagedObject;
040 import org.opends.server.admin.client.ManagedObjectDecodingException;
041 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
042 import org.opends.server.admin.client.OperationRejectedException;
043 import org.opends.server.admin.DefaultBehaviorException;
044 import org.opends.server.admin.DefaultBehaviorProvider;
045 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
046 import org.opends.server.admin.DefinitionDecodingException;
047 import org.opends.server.admin.InstantiableRelationDefinition;
048 import org.opends.server.admin.IntegerPropertyDefinition;
049 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
050 import org.opends.server.admin.ManagedObjectDefinition;
051 import org.opends.server.admin.ManagedObjectNotFoundException;
052 import org.opends.server.admin.OptionalRelationDefinition;
053 import org.opends.server.admin.PropertyOption;
054 import org.opends.server.admin.PropertyProvider;
055 import org.opends.server.admin.server.ConfigurationAddListener;
056 import org.opends.server.admin.server.ConfigurationChangeListener;
057 import org.opends.server.admin.server.ConfigurationDeleteListener;
058 import org.opends.server.admin.server.ServerManagedObject;
059 import org.opends.server.admin.std.client.ReplicationDomainCfgClient;
060 import org.opends.server.admin.std.client.ReplicationServerCfgClient;
061 import org.opends.server.admin.std.client.ReplicationSynchronizationProviderCfgClient;
062 import org.opends.server.admin.std.server.ReplicationDomainCfg;
063 import org.opends.server.admin.std.server.ReplicationServerCfg;
064 import org.opends.server.admin.std.server.ReplicationSynchronizationProviderCfg;
065 import org.opends.server.admin.std.server.SynchronizationProviderCfg;
066 import org.opends.server.admin.Tag;
067 import org.opends.server.config.ConfigException;
068 import org.opends.server.types.DN;
069
070
071
072 /**
073 * An interface for querying the Replication Synchronization Provider
074 * managed object definition meta information.
075 * <p>
076 * The Replication Synchronization Provider provides multi-master
077 * replication of data across multiple Directory Server instances.
078 */
079 public final class ReplicationSynchronizationProviderCfgDefn extends ManagedObjectDefinition<ReplicationSynchronizationProviderCfgClient, ReplicationSynchronizationProviderCfg> {
080
081 // The singleton configuration definition instance.
082 private static final ReplicationSynchronizationProviderCfgDefn INSTANCE = new ReplicationSynchronizationProviderCfgDefn();
083
084
085
086 // The "java-class" property definition.
087 private static final ClassPropertyDefinition PD_JAVA_CLASS;
088
089
090
091 // The "num-update-replay-threads" property definition.
092 private static final IntegerPropertyDefinition PD_NUM_UPDATE_REPLAY_THREADS;
093
094
095
096 // The "replication-domains" relation definition.
097 private static final InstantiableRelationDefinition<ReplicationDomainCfgClient, ReplicationDomainCfg> RD_REPLICATION_DOMAINS;
098
099
100
101 // The "replication-server" relation definition.
102 private static final OptionalRelationDefinition<ReplicationServerCfgClient, ReplicationServerCfg> RD_REPLICATION_SERVER;
103
104
105
106 // Build the "java-class" property definition.
107 static {
108 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
109 builder.setOption(PropertyOption.MANDATORY);
110 builder.setOption(PropertyOption.ADVANCED);
111 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
112 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.replication.plugin.MultimasterReplication");
113 builder.setDefaultBehaviorProvider(provider);
114 builder.addInstanceOf("org.opends.server.api.SynchronizationProvider");
115 PD_JAVA_CLASS = builder.getInstance();
116 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
117 }
118
119
120
121 // Build the "num-update-replay-threads" property definition.
122 static {
123 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "num-update-replay-threads");
124 builder.setOption(PropertyOption.ADVANCED);
125 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "num-update-replay-threads"));
126 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10");
127 builder.setDefaultBehaviorProvider(provider);
128 builder.setUpperLimit(65535);
129 builder.setLowerLimit(1);
130 PD_NUM_UPDATE_REPLAY_THREADS = builder.getInstance();
131 INSTANCE.registerPropertyDefinition(PD_NUM_UPDATE_REPLAY_THREADS);
132 }
133
134
135
136 // Build the "replication-domains" relation definition.
137 static {
138 InstantiableRelationDefinition.Builder<ReplicationDomainCfgClient, ReplicationDomainCfg> builder =
139 new InstantiableRelationDefinition.Builder<ReplicationDomainCfgClient, ReplicationDomainCfg>(INSTANCE, "replication-domain", "replication-domains", ReplicationDomainCfgDefn.getInstance());
140 RD_REPLICATION_DOMAINS = builder.getInstance();
141 INSTANCE.registerRelationDefinition(RD_REPLICATION_DOMAINS);
142 }
143
144
145
146 // Build the "replication-server" relation definition.
147 static {
148 OptionalRelationDefinition.Builder<ReplicationServerCfgClient, ReplicationServerCfg> builder =
149 new OptionalRelationDefinition.Builder<ReplicationServerCfgClient, ReplicationServerCfg>(INSTANCE, "replication-server", ReplicationServerCfgDefn.getInstance());
150 RD_REPLICATION_SERVER = builder.getInstance();
151 INSTANCE.registerRelationDefinition(RD_REPLICATION_SERVER);
152 }
153
154
155
156 // Register the tags associated with this managed object definition.
157 static {
158 INSTANCE.registerTag(Tag.valueOf("replication"));
159 }
160
161
162
163 /**
164 * Get the Replication Synchronization Provider configuration
165 * definition singleton.
166 *
167 * @return Returns the Replication Synchronization Provider
168 * configuration definition singleton.
169 */
170 public static ReplicationSynchronizationProviderCfgDefn getInstance() {
171 return INSTANCE;
172 }
173
174
175
176 /**
177 * Private constructor.
178 */
179 private ReplicationSynchronizationProviderCfgDefn() {
180 super("replication-synchronization-provider", SynchronizationProviderCfgDefn.getInstance());
181 }
182
183
184
185 /**
186 * {@inheritDoc}
187 */
188 public ReplicationSynchronizationProviderCfgClient createClientConfiguration(
189 ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl) {
190 return new ReplicationSynchronizationProviderCfgClientImpl(impl);
191 }
192
193
194
195 /**
196 * {@inheritDoc}
197 */
198 public ReplicationSynchronizationProviderCfg createServerConfiguration(
199 ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl) {
200 return new ReplicationSynchronizationProviderCfgServerImpl(impl);
201 }
202
203
204
205 /**
206 * {@inheritDoc}
207 */
208 public Class<ReplicationSynchronizationProviderCfg> getServerConfigurationClass() {
209 return ReplicationSynchronizationProviderCfg.class;
210 }
211
212
213
214 /**
215 * Get the "enabled" property definition.
216 * <p>
217 * Indicates whether the Replication Synchronization Provider is
218 * enabled for use.
219 *
220 * @return Returns the "enabled" property definition.
221 */
222 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
223 return SynchronizationProviderCfgDefn.getInstance().getEnabledPropertyDefinition();
224 }
225
226
227
228 /**
229 * Get the "java-class" property definition.
230 * <p>
231 * Specifies the fully-qualified name of the Java class that
232 * provides the Replication Synchronization Provider implementation.
233 *
234 * @return Returns the "java-class" property definition.
235 */
236 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
237 return PD_JAVA_CLASS;
238 }
239
240
241
242 /**
243 * Get the "num-update-replay-threads" property definition.
244 * <p>
245 * Specifies the number of update replay threads.
246 * <p>
247 * This value is the number of threads created for replaying every
248 * updates received for all the replication domains.
249 *
250 * @return Returns the "num-update-replay-threads" property definition.
251 */
252 public IntegerPropertyDefinition getNumUpdateReplayThreadsPropertyDefinition() {
253 return PD_NUM_UPDATE_REPLAY_THREADS;
254 }
255
256
257
258 /**
259 * Get the "replication-domains" relation definition.
260 *
261 * @return Returns the "replication-domains" relation definition.
262 */
263 public InstantiableRelationDefinition<ReplicationDomainCfgClient,ReplicationDomainCfg> getReplicationDomainsRelationDefinition() {
264 return RD_REPLICATION_DOMAINS;
265 }
266
267
268
269 /**
270 * Get the "replication-server" relation definition.
271 *
272 * @return Returns the "replication-server" relation definition.
273 */
274 public OptionalRelationDefinition<ReplicationServerCfgClient,ReplicationServerCfg> getReplicationServerRelationDefinition() {
275 return RD_REPLICATION_SERVER;
276 }
277
278
279
280 /**
281 * Managed object client implementation.
282 */
283 private static class ReplicationSynchronizationProviderCfgClientImpl implements
284 ReplicationSynchronizationProviderCfgClient {
285
286 // Private implementation.
287 private ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl;
288
289
290
291 // Private constructor.
292 private ReplicationSynchronizationProviderCfgClientImpl(
293 ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl) {
294 this.impl = impl;
295 }
296
297
298
299 /**
300 * {@inheritDoc}
301 */
302 public Boolean isEnabled() {
303 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
304 }
305
306
307
308 /**
309 * {@inheritDoc}
310 */
311 public void setEnabled(boolean value) {
312 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
313 }
314
315
316
317 /**
318 * {@inheritDoc}
319 */
320 public String getJavaClass() {
321 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
322 }
323
324
325
326 /**
327 * {@inheritDoc}
328 */
329 public void setJavaClass(String value) {
330 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
331 }
332
333
334
335 /**
336 * {@inheritDoc}
337 */
338 public int getNumUpdateReplayThreads() {
339 return impl.getPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition());
340 }
341
342
343
344 /**
345 * {@inheritDoc}
346 */
347 public void setNumUpdateReplayThreads(Integer value) {
348 impl.setPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition(), value);
349 }
350
351
352
353 /**
354 * {@inheritDoc}
355 */
356 public String[] listReplicationDomains() throws ConcurrentModificationException,
357 AuthorizationException, CommunicationException {
358 return impl.listChildren(INSTANCE.getReplicationDomainsRelationDefinition());
359 }
360
361
362
363 /**
364 * {@inheritDoc}
365 */
366 public ReplicationDomainCfgClient getReplicationDomain(String name)
367 throws DefinitionDecodingException, ManagedObjectDecodingException,
368 ManagedObjectNotFoundException, ConcurrentModificationException,
369 AuthorizationException, CommunicationException {
370 return impl.getChild(INSTANCE.getReplicationDomainsRelationDefinition(), name).getConfiguration();
371 }
372
373
374
375 /**
376 * {@inheritDoc}
377 */
378 public <M extends ReplicationDomainCfgClient> M createReplicationDomain(
379 ManagedObjectDefinition<M, ? extends ReplicationDomainCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
380 return impl.createChild(INSTANCE.getReplicationDomainsRelationDefinition(), d, name, exceptions).getConfiguration();
381 }
382
383
384
385 /**
386 * {@inheritDoc}
387 */
388 public void removeReplicationDomain(String name)
389 throws ManagedObjectNotFoundException, ConcurrentModificationException,
390 OperationRejectedException, AuthorizationException, CommunicationException {
391 impl.removeChild(INSTANCE.getReplicationDomainsRelationDefinition(), name);
392 }
393
394
395
396 /**
397 * {@inheritDoc}
398 */
399 public boolean hasReplicationServer() throws ConcurrentModificationException,
400 AuthorizationException, CommunicationException {
401 return impl.hasChild(INSTANCE.getReplicationServerRelationDefinition());
402 }
403
404
405
406 /**
407 * {@inheritDoc}
408 */
409 public ReplicationServerCfgClient getReplicationServer()
410 throws DefinitionDecodingException, ManagedObjectDecodingException,
411 ManagedObjectNotFoundException, ConcurrentModificationException,
412 AuthorizationException, CommunicationException {
413 return impl.getChild(INSTANCE.getReplicationServerRelationDefinition()).getConfiguration();
414 }
415
416
417
418 /**
419 * {@inheritDoc}
420 */
421 public <M extends ReplicationServerCfgClient> M createReplicationServer(
422 ManagedObjectDefinition<M, ? extends ReplicationServerCfg> d, Collection<DefaultBehaviorException> exceptions) {
423 return impl.createChild(INSTANCE.getReplicationServerRelationDefinition(), d, exceptions).getConfiguration();
424 }
425
426
427
428 /**
429 * {@inheritDoc}
430 */
431 public void removeReplicationServer()
432 throws ManagedObjectNotFoundException, ConcurrentModificationException,
433 OperationRejectedException, AuthorizationException, CommunicationException {
434 impl.removeChild(INSTANCE.getReplicationServerRelationDefinition());
435 }
436
437
438
439 /**
440 * {@inheritDoc}
441 */
442 public ManagedObjectDefinition<? extends ReplicationSynchronizationProviderCfgClient, ? extends ReplicationSynchronizationProviderCfg> definition() {
443 return INSTANCE;
444 }
445
446
447
448 /**
449 * {@inheritDoc}
450 */
451 public PropertyProvider properties() {
452 return impl;
453 }
454
455
456
457 /**
458 * {@inheritDoc}
459 */
460 public void commit() throws ManagedObjectAlreadyExistsException,
461 MissingMandatoryPropertiesException, ConcurrentModificationException,
462 OperationRejectedException, AuthorizationException,
463 CommunicationException {
464 impl.commit();
465 }
466
467 }
468
469
470
471 /**
472 * Managed object server implementation.
473 */
474 private static class ReplicationSynchronizationProviderCfgServerImpl implements
475 ReplicationSynchronizationProviderCfg {
476
477 // Private implementation.
478 private ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl;
479
480 // The value of the "enabled" property.
481 private final boolean pEnabled;
482
483 // The value of the "java-class" property.
484 private final String pJavaClass;
485
486 // The value of the "num-update-replay-threads" property.
487 private final int pNumUpdateReplayThreads;
488
489
490
491 // Private constructor.
492 private ReplicationSynchronizationProviderCfgServerImpl(ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl) {
493 this.impl = impl;
494 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
495 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
496 this.pNumUpdateReplayThreads = impl.getPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition());
497 }
498
499
500
501 /**
502 * {@inheritDoc}
503 */
504 public void addReplicationChangeListener(
505 ConfigurationChangeListener<ReplicationSynchronizationProviderCfg> listener) {
506 impl.registerChangeListener(listener);
507 }
508
509
510
511 /**
512 * {@inheritDoc}
513 */
514 public void removeReplicationChangeListener(
515 ConfigurationChangeListener<ReplicationSynchronizationProviderCfg> listener) {
516 impl.deregisterChangeListener(listener);
517 }
518 /**
519 * {@inheritDoc}
520 */
521 public void addChangeListener(
522 ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
523 impl.registerChangeListener(listener);
524 }
525
526
527
528 /**
529 * {@inheritDoc}
530 */
531 public void removeChangeListener(
532 ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
533 impl.deregisterChangeListener(listener);
534 }
535
536
537
538 /**
539 * {@inheritDoc}
540 */
541 public boolean isEnabled() {
542 return pEnabled;
543 }
544
545
546
547 /**
548 * {@inheritDoc}
549 */
550 public String getJavaClass() {
551 return pJavaClass;
552 }
553
554
555
556 /**
557 * {@inheritDoc}
558 */
559 public int getNumUpdateReplayThreads() {
560 return pNumUpdateReplayThreads;
561 }
562
563
564
565 /**
566 * {@inheritDoc}
567 */
568 public String[] listReplicationDomains() {
569 return impl.listChildren(INSTANCE.getReplicationDomainsRelationDefinition());
570 }
571
572
573
574 /**
575 * {@inheritDoc}
576 */
577 public ReplicationDomainCfg getReplicationDomain(String name) throws ConfigException {
578 return impl.getChild(INSTANCE.getReplicationDomainsRelationDefinition(), name).getConfiguration();
579 }
580
581
582
583 /**
584 * {@inheritDoc}
585 */
586 public void addReplicationDomainAddListener(
587 ConfigurationAddListener<ReplicationDomainCfg> listener) throws ConfigException {
588 impl.registerAddListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
589 }
590
591
592
593 /**
594 * {@inheritDoc}
595 */
596 public void removeReplicationDomainAddListener(
597 ConfigurationAddListener<ReplicationDomainCfg> listener) {
598 impl.deregisterAddListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
599 }
600
601
602
603 /**
604 * {@inheritDoc}
605 */
606 public void addReplicationDomainDeleteListener(
607 ConfigurationDeleteListener<ReplicationDomainCfg> listener) throws ConfigException {
608 impl.registerDeleteListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
609 }
610
611
612
613 /**
614 * {@inheritDoc}
615 */
616 public void removeReplicationDomainDeleteListener(
617 ConfigurationDeleteListener<ReplicationDomainCfg> listener) {
618 impl.deregisterDeleteListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
619 }
620
621
622
623 /**
624 * {@inheritDoc}
625 */
626 public boolean hasReplicationServer() {
627 return impl.hasChild(INSTANCE.getReplicationServerRelationDefinition());
628 }
629
630
631
632 /**
633 * {@inheritDoc}
634 */
635 public ReplicationServerCfg getReplicationServer() throws ConfigException {
636 return impl.getChild(INSTANCE.getReplicationServerRelationDefinition()).getConfiguration();
637 }
638
639
640
641 /**
642 * {@inheritDoc}
643 */
644 public void addReplicationServerAddListener(
645 ConfigurationAddListener<ReplicationServerCfg> listener) throws ConfigException {
646 impl.registerAddListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
647 }
648
649
650
651 /**
652 * {@inheritDoc}
653 */
654 public void removeReplicationServerAddListener(
655 ConfigurationAddListener<ReplicationServerCfg> listener) {
656 impl.deregisterAddListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
657 }
658
659
660
661 /**
662 * {@inheritDoc}
663 */
664 public void addReplicationServerDeleteListener(
665 ConfigurationDeleteListener<ReplicationServerCfg> listener) throws ConfigException {
666 impl.registerDeleteListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
667 }
668
669
670
671 /**
672 * {@inheritDoc}
673 */
674 public void removeReplicationServerDeleteListener(
675 ConfigurationDeleteListener<ReplicationServerCfg> listener) {
676 impl.deregisterDeleteListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
677 }
678
679
680
681 /**
682 * {@inheritDoc}
683 */
684 public Class<? extends ReplicationSynchronizationProviderCfg> configurationClass() {
685 return ReplicationSynchronizationProviderCfg.class;
686 }
687
688
689
690 /**
691 * {@inheritDoc}
692 */
693 public DN dn() {
694 return impl.getDN();
695 }
696
697 }
698 }