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.AliasDefaultBehaviorProvider;
035 import org.opends.server.admin.BooleanPropertyDefinition;
036 import org.opends.server.admin.ClassPropertyDefinition;
037 import org.opends.server.admin.client.AuthorizationException;
038 import org.opends.server.admin.client.CommunicationException;
039 import org.opends.server.admin.client.ConcurrentModificationException;
040 import org.opends.server.admin.client.ManagedObject;
041 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
042 import org.opends.server.admin.client.OperationRejectedException;
043 import org.opends.server.admin.IPAddressMaskPropertyDefinition;
044 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
045 import org.opends.server.admin.ManagedObjectDefinition;
046 import org.opends.server.admin.PropertyOption;
047 import org.opends.server.admin.PropertyProvider;
048 import org.opends.server.admin.server.ConfigurationChangeListener;
049 import org.opends.server.admin.server.ServerManagedObject;
050 import org.opends.server.admin.std.client.ConnectionHandlerCfgClient;
051 import org.opends.server.admin.std.server.ConnectionHandlerCfg;
052 import org.opends.server.admin.Tag;
053 import org.opends.server.admin.TopCfgDefn;
054 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
055 import org.opends.server.types.AddressMask;
056 import org.opends.server.types.DN;
057
058
059
060 /**
061 * An interface for querying the Connection Handler managed object
062 * definition meta information.
063 * <p>
064 * Connection Handlers are responsible for handling all interaction
065 * with the clients, including accepting the connections, reading
066 * requests, and sending responses.
067 */
068 public final class ConnectionHandlerCfgDefn extends ManagedObjectDefinition<ConnectionHandlerCfgClient, ConnectionHandlerCfg> {
069
070 // The singleton configuration definition instance.
071 private static final ConnectionHandlerCfgDefn INSTANCE = new ConnectionHandlerCfgDefn();
072
073
074
075 // The "allowed-client" property definition.
076 private static final IPAddressMaskPropertyDefinition PD_ALLOWED_CLIENT;
077
078
079
080 // The "denied-client" property definition.
081 private static final IPAddressMaskPropertyDefinition PD_DENIED_CLIENT;
082
083
084
085 // The "enabled" property definition.
086 private static final BooleanPropertyDefinition PD_ENABLED;
087
088
089
090 // The "java-class" property definition.
091 private static final ClassPropertyDefinition PD_JAVA_CLASS;
092
093
094
095 // Build the "allowed-client" property definition.
096 static {
097 IPAddressMaskPropertyDefinition.Builder builder = IPAddressMaskPropertyDefinition.createBuilder(INSTANCE, "allowed-client");
098 builder.setOption(PropertyOption.MULTI_VALUED);
099 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allowed-client"));
100 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<AddressMask>(INSTANCE, "allowed-client"));
101 PD_ALLOWED_CLIENT = builder.getInstance();
102 INSTANCE.registerPropertyDefinition(PD_ALLOWED_CLIENT);
103 }
104
105
106
107 // Build the "denied-client" property definition.
108 static {
109 IPAddressMaskPropertyDefinition.Builder builder = IPAddressMaskPropertyDefinition.createBuilder(INSTANCE, "denied-client");
110 builder.setOption(PropertyOption.MULTI_VALUED);
111 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "denied-client"));
112 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<AddressMask>(INSTANCE, "denied-client"));
113 PD_DENIED_CLIENT = builder.getInstance();
114 INSTANCE.registerPropertyDefinition(PD_DENIED_CLIENT);
115 }
116
117
118
119 // Build the "enabled" property definition.
120 static {
121 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled");
122 builder.setOption(PropertyOption.MANDATORY);
123 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled"));
124 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
125 PD_ENABLED = builder.getInstance();
126 INSTANCE.registerPropertyDefinition(PD_ENABLED);
127 }
128
129
130
131 // Build the "java-class" property definition.
132 static {
133 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
134 builder.setOption(PropertyOption.MANDATORY);
135 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
136 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
137 builder.addInstanceOf("org.opends.server.api.ConnectionHandler");
138 PD_JAVA_CLASS = builder.getInstance();
139 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
140 }
141
142
143
144 // Register the tags associated with this managed object definition.
145 static {
146 INSTANCE.registerTag(Tag.valueOf("core-server"));
147 }
148
149
150
151 /**
152 * Get the Connection Handler configuration definition singleton.
153 *
154 * @return Returns the Connection Handler configuration definition
155 * singleton.
156 */
157 public static ConnectionHandlerCfgDefn getInstance() {
158 return INSTANCE;
159 }
160
161
162
163 /**
164 * Private constructor.
165 */
166 private ConnectionHandlerCfgDefn() {
167 super("connection-handler", TopCfgDefn.getInstance());
168 }
169
170
171
172 /**
173 * {@inheritDoc}
174 */
175 public ConnectionHandlerCfgClient createClientConfiguration(
176 ManagedObject<? extends ConnectionHandlerCfgClient> impl) {
177 return new ConnectionHandlerCfgClientImpl(impl);
178 }
179
180
181
182 /**
183 * {@inheritDoc}
184 */
185 public ConnectionHandlerCfg createServerConfiguration(
186 ServerManagedObject<? extends ConnectionHandlerCfg> impl) {
187 return new ConnectionHandlerCfgServerImpl(impl);
188 }
189
190
191
192 /**
193 * {@inheritDoc}
194 */
195 public Class<ConnectionHandlerCfg> getServerConfigurationClass() {
196 return ConnectionHandlerCfg.class;
197 }
198
199
200
201 /**
202 * Get the "allowed-client" property definition.
203 * <p>
204 * Specifies a set of address masks that determines the addresses of
205 * the clients that are allowed to establish connections to this
206 * connection handler.
207 *
208 * @return Returns the "allowed-client" property definition.
209 */
210 public IPAddressMaskPropertyDefinition getAllowedClientPropertyDefinition() {
211 return PD_ALLOWED_CLIENT;
212 }
213
214
215
216 /**
217 * Get the "denied-client" property definition.
218 * <p>
219 * Specifies a set of address masks that determines the addresses of
220 * the clients that are not allowed to establish connections to this
221 * connection handler.
222 * <p>
223 * If both allowed and denied client masks are defined and a client
224 * connection matches one or more masks in both lists, then the
225 * connection is denied. If only a denied list is specified, then any
226 * client not matching a mask in that list is allowed.
227 *
228 * @return Returns the "denied-client" property definition.
229 */
230 public IPAddressMaskPropertyDefinition getDeniedClientPropertyDefinition() {
231 return PD_DENIED_CLIENT;
232 }
233
234
235
236 /**
237 * Get the "enabled" property definition.
238 * <p>
239 * Indicates whether the Connection Handler is enabled.
240 *
241 * @return Returns the "enabled" property definition.
242 */
243 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
244 return PD_ENABLED;
245 }
246
247
248
249 /**
250 * Get the "java-class" property definition.
251 * <p>
252 * Specifies the fully-qualified name of the Java class that
253 * provides the Connection Handler implementation.
254 *
255 * @return Returns the "java-class" property definition.
256 */
257 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
258 return PD_JAVA_CLASS;
259 }
260
261
262
263 /**
264 * Managed object client implementation.
265 */
266 private static class ConnectionHandlerCfgClientImpl implements
267 ConnectionHandlerCfgClient {
268
269 // Private implementation.
270 private ManagedObject<? extends ConnectionHandlerCfgClient> impl;
271
272
273
274 // Private constructor.
275 private ConnectionHandlerCfgClientImpl(
276 ManagedObject<? extends ConnectionHandlerCfgClient> impl) {
277 this.impl = impl;
278 }
279
280
281
282 /**
283 * {@inheritDoc}
284 */
285 public SortedSet<AddressMask> getAllowedClient() {
286 return impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
287 }
288
289
290
291 /**
292 * {@inheritDoc}
293 */
294 public void setAllowedClient(Collection<AddressMask> values) {
295 impl.setPropertyValues(INSTANCE.getAllowedClientPropertyDefinition(), values);
296 }
297
298
299
300 /**
301 * {@inheritDoc}
302 */
303 public SortedSet<AddressMask> getDeniedClient() {
304 return impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
305 }
306
307
308
309 /**
310 * {@inheritDoc}
311 */
312 public void setDeniedClient(Collection<AddressMask> values) {
313 impl.setPropertyValues(INSTANCE.getDeniedClientPropertyDefinition(), values);
314 }
315
316
317
318 /**
319 * {@inheritDoc}
320 */
321 public Boolean isEnabled() {
322 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
323 }
324
325
326
327 /**
328 * {@inheritDoc}
329 */
330 public void setEnabled(boolean value) {
331 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
332 }
333
334
335
336 /**
337 * {@inheritDoc}
338 */
339 public String getJavaClass() {
340 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
341 }
342
343
344
345 /**
346 * {@inheritDoc}
347 */
348 public void setJavaClass(String value) {
349 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
350 }
351
352
353
354 /**
355 * {@inheritDoc}
356 */
357 public ManagedObjectDefinition<? extends ConnectionHandlerCfgClient, ? extends ConnectionHandlerCfg> definition() {
358 return INSTANCE;
359 }
360
361
362
363 /**
364 * {@inheritDoc}
365 */
366 public PropertyProvider properties() {
367 return impl;
368 }
369
370
371
372 /**
373 * {@inheritDoc}
374 */
375 public void commit() throws ManagedObjectAlreadyExistsException,
376 MissingMandatoryPropertiesException, ConcurrentModificationException,
377 OperationRejectedException, AuthorizationException,
378 CommunicationException {
379 impl.commit();
380 }
381
382 }
383
384
385
386 /**
387 * Managed object server implementation.
388 */
389 private static class ConnectionHandlerCfgServerImpl implements
390 ConnectionHandlerCfg {
391
392 // Private implementation.
393 private ServerManagedObject<? extends ConnectionHandlerCfg> impl;
394
395 // The value of the "allowed-client" property.
396 private final SortedSet<AddressMask> pAllowedClient;
397
398 // The value of the "denied-client" property.
399 private final SortedSet<AddressMask> pDeniedClient;
400
401 // The value of the "enabled" property.
402 private final boolean pEnabled;
403
404 // The value of the "java-class" property.
405 private final String pJavaClass;
406
407
408
409 // Private constructor.
410 private ConnectionHandlerCfgServerImpl(ServerManagedObject<? extends ConnectionHandlerCfg> impl) {
411 this.impl = impl;
412 this.pAllowedClient = impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
413 this.pDeniedClient = impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
414 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
415 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
416 }
417
418
419
420 /**
421 * {@inheritDoc}
422 */
423 public void addChangeListener(
424 ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
425 impl.registerChangeListener(listener);
426 }
427
428
429
430 /**
431 * {@inheritDoc}
432 */
433 public void removeChangeListener(
434 ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
435 impl.deregisterChangeListener(listener);
436 }
437
438
439
440 /**
441 * {@inheritDoc}
442 */
443 public SortedSet<AddressMask> getAllowedClient() {
444 return pAllowedClient;
445 }
446
447
448
449 /**
450 * {@inheritDoc}
451 */
452 public SortedSet<AddressMask> getDeniedClient() {
453 return pDeniedClient;
454 }
455
456
457
458 /**
459 * {@inheritDoc}
460 */
461 public boolean isEnabled() {
462 return pEnabled;
463 }
464
465
466
467 /**
468 * {@inheritDoc}
469 */
470 public String getJavaClass() {
471 return pJavaClass;
472 }
473
474
475
476 /**
477 * {@inheritDoc}
478 */
479 public Class<? extends ConnectionHandlerCfg> configurationClass() {
480 return ConnectionHandlerCfg.class;
481 }
482
483
484
485 /**
486 * {@inheritDoc}
487 */
488 public DN dn() {
489 return impl.getDN();
490 }
491
492 }
493 }