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 org.opends.server.admin.AdministratorAction;
032 import org.opends.server.admin.BooleanPropertyDefinition;
033 import org.opends.server.admin.ClassPropertyDefinition;
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.ManagedObjectAlreadyExistsException;
041 import org.opends.server.admin.ManagedObjectDefinition;
042 import org.opends.server.admin.PropertyOption;
043 import org.opends.server.admin.PropertyProvider;
044 import org.opends.server.admin.server.ConfigurationChangeListener;
045 import org.opends.server.admin.server.ServerManagedObject;
046 import org.opends.server.admin.std.client.SynchronizationProviderCfgClient;
047 import org.opends.server.admin.std.server.SynchronizationProviderCfg;
048 import org.opends.server.admin.Tag;
049 import org.opends.server.admin.TopCfgDefn;
050 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
051 import org.opends.server.types.DN;
052
053
054
055 /**
056 * An interface for querying the Synchronization Provider managed
057 * object definition meta information.
058 * <p>
059 * Synchronization Providers are responsible for handling
060 * synchronization of the Directory Server data with other OpenDS
061 * instances or other data repositories.
062 */
063 public final class SynchronizationProviderCfgDefn extends ManagedObjectDefinition<SynchronizationProviderCfgClient, SynchronizationProviderCfg> {
064
065 // The singleton configuration definition instance.
066 private static final SynchronizationProviderCfgDefn INSTANCE = new SynchronizationProviderCfgDefn();
067
068
069
070 // The "enabled" property definition.
071 private static final BooleanPropertyDefinition PD_ENABLED;
072
073
074
075 // The "java-class" property definition.
076 private static final ClassPropertyDefinition PD_JAVA_CLASS;
077
078
079
080 // Build the "enabled" property definition.
081 static {
082 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled");
083 builder.setOption(PropertyOption.MANDATORY);
084 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled"));
085 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
086 PD_ENABLED = builder.getInstance();
087 INSTANCE.registerPropertyDefinition(PD_ENABLED);
088 }
089
090
091
092 // Build the "java-class" property definition.
093 static {
094 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
095 builder.setOption(PropertyOption.MANDATORY);
096 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
097 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
098 builder.addInstanceOf("org.opends.server.api.SynchronizationProvider");
099 PD_JAVA_CLASS = builder.getInstance();
100 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
101 }
102
103
104
105 // Register the tags associated with this managed object definition.
106 static {
107 INSTANCE.registerTag(Tag.valueOf("replication"));
108 }
109
110
111
112 /**
113 * Get the Synchronization Provider configuration definition
114 * singleton.
115 *
116 * @return Returns the Synchronization Provider configuration
117 * definition singleton.
118 */
119 public static SynchronizationProviderCfgDefn getInstance() {
120 return INSTANCE;
121 }
122
123
124
125 /**
126 * Private constructor.
127 */
128 private SynchronizationProviderCfgDefn() {
129 super("synchronization-provider", TopCfgDefn.getInstance());
130 }
131
132
133
134 /**
135 * {@inheritDoc}
136 */
137 public SynchronizationProviderCfgClient createClientConfiguration(
138 ManagedObject<? extends SynchronizationProviderCfgClient> impl) {
139 return new SynchronizationProviderCfgClientImpl(impl);
140 }
141
142
143
144 /**
145 * {@inheritDoc}
146 */
147 public SynchronizationProviderCfg createServerConfiguration(
148 ServerManagedObject<? extends SynchronizationProviderCfg> impl) {
149 return new SynchronizationProviderCfgServerImpl(impl);
150 }
151
152
153
154 /**
155 * {@inheritDoc}
156 */
157 public Class<SynchronizationProviderCfg> getServerConfigurationClass() {
158 return SynchronizationProviderCfg.class;
159 }
160
161
162
163 /**
164 * Get the "enabled" property definition.
165 * <p>
166 * Indicates whether the Synchronization Provider is enabled for
167 * use.
168 *
169 * @return Returns the "enabled" property definition.
170 */
171 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
172 return PD_ENABLED;
173 }
174
175
176
177 /**
178 * Get the "java-class" property definition.
179 * <p>
180 * Specifies the fully-qualified name of the Java class that
181 * provides the Synchronization Provider implementation.
182 *
183 * @return Returns the "java-class" property definition.
184 */
185 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
186 return PD_JAVA_CLASS;
187 }
188
189
190
191 /**
192 * Managed object client implementation.
193 */
194 private static class SynchronizationProviderCfgClientImpl implements
195 SynchronizationProviderCfgClient {
196
197 // Private implementation.
198 private ManagedObject<? extends SynchronizationProviderCfgClient> impl;
199
200
201
202 // Private constructor.
203 private SynchronizationProviderCfgClientImpl(
204 ManagedObject<? extends SynchronizationProviderCfgClient> impl) {
205 this.impl = impl;
206 }
207
208
209
210 /**
211 * {@inheritDoc}
212 */
213 public Boolean isEnabled() {
214 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
215 }
216
217
218
219 /**
220 * {@inheritDoc}
221 */
222 public void setEnabled(boolean value) {
223 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
224 }
225
226
227
228 /**
229 * {@inheritDoc}
230 */
231 public String getJavaClass() {
232 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
233 }
234
235
236
237 /**
238 * {@inheritDoc}
239 */
240 public void setJavaClass(String value) {
241 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
242 }
243
244
245
246 /**
247 * {@inheritDoc}
248 */
249 public ManagedObjectDefinition<? extends SynchronizationProviderCfgClient, ? extends SynchronizationProviderCfg> definition() {
250 return INSTANCE;
251 }
252
253
254
255 /**
256 * {@inheritDoc}
257 */
258 public PropertyProvider properties() {
259 return impl;
260 }
261
262
263
264 /**
265 * {@inheritDoc}
266 */
267 public void commit() throws ManagedObjectAlreadyExistsException,
268 MissingMandatoryPropertiesException, ConcurrentModificationException,
269 OperationRejectedException, AuthorizationException,
270 CommunicationException {
271 impl.commit();
272 }
273
274 }
275
276
277
278 /**
279 * Managed object server implementation.
280 */
281 private static class SynchronizationProviderCfgServerImpl implements
282 SynchronizationProviderCfg {
283
284 // Private implementation.
285 private ServerManagedObject<? extends SynchronizationProviderCfg> impl;
286
287 // The value of the "enabled" property.
288 private final boolean pEnabled;
289
290 // The value of the "java-class" property.
291 private final String pJavaClass;
292
293
294
295 // Private constructor.
296 private SynchronizationProviderCfgServerImpl(ServerManagedObject<? extends SynchronizationProviderCfg> impl) {
297 this.impl = impl;
298 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
299 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
300 }
301
302
303
304 /**
305 * {@inheritDoc}
306 */
307 public void addChangeListener(
308 ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
309 impl.registerChangeListener(listener);
310 }
311
312
313
314 /**
315 * {@inheritDoc}
316 */
317 public void removeChangeListener(
318 ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
319 impl.deregisterChangeListener(listener);
320 }
321
322
323
324 /**
325 * {@inheritDoc}
326 */
327 public boolean isEnabled() {
328 return pEnabled;
329 }
330
331
332
333 /**
334 * {@inheritDoc}
335 */
336 public String getJavaClass() {
337 return pJavaClass;
338 }
339
340
341
342 /**
343 * {@inheritDoc}
344 */
345 public Class<? extends SynchronizationProviderCfg> configurationClass() {
346 return SynchronizationProviderCfg.class;
347 }
348
349
350
351 /**
352 * {@inheritDoc}
353 */
354 public DN dn() {
355 return impl.getDN();
356 }
357
358 }
359 }