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 legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.meta;
027
028
029
030import java.net.InetAddress;
031import java.util.Collection;
032import java.util.SortedSet;
033import org.forgerock.opendj.config.AdministratorAction;
034import org.forgerock.opendj.config.AggregationPropertyDefinition;
035import org.forgerock.opendj.config.AliasDefaultBehaviorProvider;
036import org.forgerock.opendj.config.BooleanPropertyDefinition;
037import org.forgerock.opendj.config.ClassPropertyDefinition;
038import org.forgerock.opendj.config.client.ConcurrentModificationException;
039import org.forgerock.opendj.config.client.ManagedObject;
040import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
041import org.forgerock.opendj.config.client.OperationRejectedException;
042import org.forgerock.opendj.config.conditions.Conditions;
043import org.forgerock.opendj.config.DefaultBehaviorProvider;
044import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
045import org.forgerock.opendj.config.GenericConstraint;
046import org.forgerock.opendj.config.IntegerPropertyDefinition;
047import org.forgerock.opendj.config.IPAddressMaskPropertyDefinition;
048import org.forgerock.opendj.config.IPAddressPropertyDefinition;
049import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
050import org.forgerock.opendj.config.ManagedObjectDefinition;
051import org.forgerock.opendj.config.PropertyOption;
052import org.forgerock.opendj.config.PropertyProvider;
053import org.forgerock.opendj.config.server.ConfigurationChangeListener;
054import org.forgerock.opendj.config.server.ServerManagedObject;
055import org.forgerock.opendj.config.StringPropertyDefinition;
056import org.forgerock.opendj.config.Tag;
057import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
058import org.forgerock.opendj.ldap.AddressMask;
059import org.forgerock.opendj.ldap.DN;
060import org.forgerock.opendj.ldap.LdapException;
061import org.forgerock.opendj.server.config.client.JMXConnectionHandlerCfgClient;
062import org.forgerock.opendj.server.config.client.KeyManagerProviderCfgClient;
063import org.forgerock.opendj.server.config.server.ConnectionHandlerCfg;
064import org.forgerock.opendj.server.config.server.JMXConnectionHandlerCfg;
065import org.forgerock.opendj.server.config.server.KeyManagerProviderCfg;
066
067
068
069/**
070 * An interface for querying the JMX Connection Handler managed object
071 * definition meta information.
072 * <p>
073 * The JMX Connection Handler is used to interact with clients using
074 * the Java Management Extensions (JMX) protocol.
075 */
076public final class JMXConnectionHandlerCfgDefn extends ManagedObjectDefinition<JMXConnectionHandlerCfgClient, JMXConnectionHandlerCfg> {
077
078  /** The singleton configuration definition instance. */
079  private static final JMXConnectionHandlerCfgDefn INSTANCE = new JMXConnectionHandlerCfgDefn();
080
081
082
083  /** The "java-class" property definition. */
084  private static final ClassPropertyDefinition PD_JAVA_CLASS;
085
086
087
088  /** The "key-manager-provider" property definition. */
089  private static final AggregationPropertyDefinition<KeyManagerProviderCfgClient, KeyManagerProviderCfg> PD_KEY_MANAGER_PROVIDER;
090
091
092
093  /** The "listen-address" property definition. */
094  private static final IPAddressPropertyDefinition PD_LISTEN_ADDRESS;
095
096
097
098  /** The "listen-port" property definition. */
099  private static final IntegerPropertyDefinition PD_LISTEN_PORT;
100
101
102
103  /** The "rmi-port" property definition. */
104  private static final IntegerPropertyDefinition PD_RMI_PORT;
105
106
107
108  /** The "ssl-cert-nickname" property definition. */
109  private static final StringPropertyDefinition PD_SSL_CERT_NICKNAME;
110
111
112
113  /** The "use-ssl" property definition. */
114  private static final BooleanPropertyDefinition PD_USE_SSL;
115
116
117
118  /** Build the "java-class" property definition. */
119  static {
120      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
121      builder.setOption(PropertyOption.MANDATORY);
122      builder.setOption(PropertyOption.ADVANCED);
123      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
124      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.protocols.jmx.JmxConnectionHandler");
125      builder.setDefaultBehaviorProvider(provider);
126      builder.addInstanceOf("org.opends.server.api.ConnectionHandler");
127      PD_JAVA_CLASS = builder.getInstance();
128      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
129  }
130
131
132
133  /** Build the "key-manager-provider" property definition. */
134  static {
135      AggregationPropertyDefinition.Builder<KeyManagerProviderCfgClient, KeyManagerProviderCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "key-manager-provider");
136      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "key-manager-provider"));
137      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
138      builder.setParentPath("/");
139      builder.setRelationDefinition("key-manager-provider");
140      builder.setTargetNeedsEnablingCondition(Conditions.and(Conditions.contains("enabled", "true"), Conditions.contains("use-ssl", "true")));
141      builder.setTargetIsEnabledCondition(Conditions.contains("enabled", "true"));
142      PD_KEY_MANAGER_PROVIDER = builder.getInstance();
143      INSTANCE.registerPropertyDefinition(PD_KEY_MANAGER_PROVIDER);
144      INSTANCE.registerConstraint(PD_KEY_MANAGER_PROVIDER.getSourceConstraint());
145  }
146
147
148
149  /** Build the "listen-address" property definition. */
150  static {
151      IPAddressPropertyDefinition.Builder builder = IPAddressPropertyDefinition.createBuilder(INSTANCE, "listen-address");
152      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "listen-address"));
153      DefaultBehaviorProvider<InetAddress> provider = new DefinedDefaultBehaviorProvider<InetAddress>("0.0.0.0");
154      builder.setDefaultBehaviorProvider(provider);
155      PD_LISTEN_ADDRESS = builder.getInstance();
156      INSTANCE.registerPropertyDefinition(PD_LISTEN_ADDRESS);
157  }
158
159
160
161  /** Build the "listen-port" property definition. */
162  static {
163      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "listen-port");
164      builder.setOption(PropertyOption.MANDATORY);
165      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "listen-port"));
166      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>());
167      builder.setUpperLimit(65535);
168      builder.setLowerLimit(1);
169      PD_LISTEN_PORT = builder.getInstance();
170      INSTANCE.registerPropertyDefinition(PD_LISTEN_PORT);
171  }
172
173
174
175  /** Build the "rmi-port" property definition. */
176  static {
177      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "rmi-port");
178      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "rmi-port"));
179      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("0");
180      builder.setDefaultBehaviorProvider(provider);
181      builder.setUpperLimit(65535);
182      builder.setLowerLimit(0);
183      PD_RMI_PORT = builder.getInstance();
184      INSTANCE.registerPropertyDefinition(PD_RMI_PORT);
185  }
186
187
188
189  /** Build the "ssl-cert-nickname" property definition. */
190  static {
191      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-cert-nickname");
192      builder.setOption(PropertyOption.MULTI_VALUED);
193      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "ssl-cert-nickname"));
194      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-cert-nickname"));
195      PD_SSL_CERT_NICKNAME = builder.getInstance();
196      INSTANCE.registerPropertyDefinition(PD_SSL_CERT_NICKNAME);
197  }
198
199
200
201  /** Build the "use-ssl" property definition. */
202  static {
203      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "use-ssl");
204      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "use-ssl"));
205      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
206      builder.setDefaultBehaviorProvider(provider);
207      PD_USE_SSL = builder.getInstance();
208      INSTANCE.registerPropertyDefinition(PD_USE_SSL);
209  }
210
211
212
213  // Register the tags associated with this managed object definition.
214  static {
215    INSTANCE.registerTag(Tag.valueOf("core-server"));
216  }
217
218
219
220  // Register the constraints associated with this managed object definition.
221  static {
222    INSTANCE.registerConstraint(new GenericConstraint(INSTANCE, 1, Conditions.implies(Conditions.contains("enabled", "true"), Conditions.implies(Conditions.contains("use-ssl", "true"), Conditions.isPresent("key-manager-provider")))));
223  }
224
225
226
227  /**
228   * Get the JMX Connection Handler configuration definition
229   * singleton.
230   *
231   * @return Returns the JMX Connection Handler configuration
232   *         definition singleton.
233   */
234  public static JMXConnectionHandlerCfgDefn getInstance() {
235    return INSTANCE;
236  }
237
238
239
240  /**
241   * Private constructor.
242   */
243  private JMXConnectionHandlerCfgDefn() {
244    super("jmx-connection-handler", ConnectionHandlerCfgDefn.getInstance());
245  }
246
247
248
249  /** {@inheritDoc} */
250  public JMXConnectionHandlerCfgClient createClientConfiguration(
251      ManagedObject<? extends JMXConnectionHandlerCfgClient> impl) {
252    return new JMXConnectionHandlerCfgClientImpl(impl);
253  }
254
255
256
257  /** {@inheritDoc} */
258  public JMXConnectionHandlerCfg createServerConfiguration(
259      ServerManagedObject<? extends JMXConnectionHandlerCfg> impl) {
260    return new JMXConnectionHandlerCfgServerImpl(impl);
261  }
262
263
264
265  /** {@inheritDoc} */
266  public Class<JMXConnectionHandlerCfg> getServerConfigurationClass() {
267    return JMXConnectionHandlerCfg.class;
268  }
269
270
271
272  /**
273   * Get the "allowed-client" property definition.
274   * <p>
275   * Specifies a set of host names or address masks that determine the
276   * clients that are allowed to establish connections to this JMX
277   * Connection Handler.
278   * <p>
279   * Valid values include a host name, a fully qualified domain name,
280   * a domain name, an IP address, or a subnetwork with subnetwork
281   * mask.
282   *
283   * @return Returns the "allowed-client" property definition.
284   */
285  public IPAddressMaskPropertyDefinition getAllowedClientPropertyDefinition() {
286    return ConnectionHandlerCfgDefn.getInstance().getAllowedClientPropertyDefinition();
287  }
288
289
290
291  /**
292   * Get the "denied-client" property definition.
293   * <p>
294   * Specifies a set of host names or address masks that determine the
295   * clients that are not allowed to establish connections to this JMX
296   * Connection Handler.
297   * <p>
298   * Valid values include a host name, a fully qualified domain name,
299   * a domain name, an IP address, or a subnetwork with subnetwork
300   * mask. If both allowed and denied client masks are defined and a
301   * client connection matches one or more masks in both lists, then
302   * the connection is denied. If only a denied list is specified, then
303   * any client not matching a mask in that list is allowed.
304   *
305   * @return Returns the "denied-client" property definition.
306   */
307  public IPAddressMaskPropertyDefinition getDeniedClientPropertyDefinition() {
308    return ConnectionHandlerCfgDefn.getInstance().getDeniedClientPropertyDefinition();
309  }
310
311
312
313  /**
314   * Get the "enabled" property definition.
315   * <p>
316   * Indicates whether the JMX Connection Handler is enabled.
317   *
318   * @return Returns the "enabled" property definition.
319   */
320  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
321    return ConnectionHandlerCfgDefn.getInstance().getEnabledPropertyDefinition();
322  }
323
324
325
326  /**
327   * Get the "java-class" property definition.
328   * <p>
329   * Specifies the fully-qualified name of the Java class that
330   * provides the JMX Connection Handler implementation.
331   *
332   * @return Returns the "java-class" property definition.
333   */
334  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
335    return PD_JAVA_CLASS;
336  }
337
338
339
340  /**
341   * Get the "key-manager-provider" property definition.
342   * <p>
343   * Specifies the name of the key manager that should be used with
344   * this JMX Connection Handler .
345   *
346   * @return Returns the "key-manager-provider" property definition.
347   */
348  public AggregationPropertyDefinition<KeyManagerProviderCfgClient, KeyManagerProviderCfg> getKeyManagerProviderPropertyDefinition() {
349    return PD_KEY_MANAGER_PROVIDER;
350  }
351
352
353
354  /**
355   * Get the "listen-address" property definition.
356   * <p>
357   * Specifies the address on which this JMX Connection Handler should
358   * listen for connections from JMX clients.
359   * <p>
360   * If no value is provided, then the JMX Connection Handler listens
361   * on all interfaces.
362   *
363   * @return Returns the "listen-address" property definition.
364   */
365  public IPAddressPropertyDefinition getListenAddressPropertyDefinition() {
366    return PD_LISTEN_ADDRESS;
367  }
368
369
370
371  /**
372   * Get the "listen-port" property definition.
373   * <p>
374   * Specifies the port number on which the JMX Connection Handler
375   * will listen for connections from clients.
376   * <p>
377   * Only a single port number may be provided.
378   *
379   * @return Returns the "listen-port" property definition.
380   */
381  public IntegerPropertyDefinition getListenPortPropertyDefinition() {
382    return PD_LISTEN_PORT;
383  }
384
385
386
387  /**
388   * Get the "rmi-port" property definition.
389   * <p>
390   * Specifies the port number on which the JMX RMI service will
391   * listen for connections from clients. A value of 0 indicates the
392   * service to choose a port of its own.
393   * <p>
394   * If the value provided is different than 0, the value will be used
395   * as the RMI port. Otherwise, the RMI service will choose a port of
396   * its own.
397   *
398   * @return Returns the "rmi-port" property definition.
399   */
400  public IntegerPropertyDefinition getRmiPortPropertyDefinition() {
401    return PD_RMI_PORT;
402  }
403
404
405
406  /**
407   * Get the "ssl-cert-nickname" property definition.
408   * <p>
409   * Specifies the nicknames (also called the aliases) of the
410   * certificates that the JMX Connection Handler should use when
411   * performing SSL communication. The property can be used multiple
412   * times (referencing different nicknames) when an RSA, a DSA, and an
413   * ECC based server certificate is used in parallel.
414   * <p>
415   * This is only applicable when the JMX Connection Handler is
416   * configured to use SSL.
417   *
418   * @return Returns the "ssl-cert-nickname" property definition.
419   */
420  public StringPropertyDefinition getSSLCertNicknamePropertyDefinition() {
421    return PD_SSL_CERT_NICKNAME;
422  }
423
424
425
426  /**
427   * Get the "use-ssl" property definition.
428   * <p>
429   * Indicates whether the JMX Connection Handler should use SSL.
430   * <p>
431   * If enabled, the JMX Connection Handler will use SSL to encrypt
432   * communication with the clients.
433   *
434   * @return Returns the "use-ssl" property definition.
435   */
436  public BooleanPropertyDefinition getUseSSLPropertyDefinition() {
437    return PD_USE_SSL;
438  }
439
440
441
442  /**
443   * Managed object client implementation.
444   */
445  private static class JMXConnectionHandlerCfgClientImpl implements
446    JMXConnectionHandlerCfgClient {
447
448    /** Private implementation. */
449    private ManagedObject<? extends JMXConnectionHandlerCfgClient> impl;
450
451
452
453    /** Private constructor. */
454    private JMXConnectionHandlerCfgClientImpl(
455        ManagedObject<? extends JMXConnectionHandlerCfgClient> impl) {
456      this.impl = impl;
457    }
458
459
460
461    /** {@inheritDoc} */
462    public SortedSet<AddressMask> getAllowedClient() {
463      return impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
464    }
465
466
467
468    /** {@inheritDoc} */
469    public void setAllowedClient(Collection<AddressMask> values) {
470      impl.setPropertyValues(INSTANCE.getAllowedClientPropertyDefinition(), values);
471    }
472
473
474
475    /** {@inheritDoc} */
476    public SortedSet<AddressMask> getDeniedClient() {
477      return impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
478    }
479
480
481
482    /** {@inheritDoc} */
483    public void setDeniedClient(Collection<AddressMask> values) {
484      impl.setPropertyValues(INSTANCE.getDeniedClientPropertyDefinition(), values);
485    }
486
487
488
489    /** {@inheritDoc} */
490    public Boolean isEnabled() {
491      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
492    }
493
494
495
496    /** {@inheritDoc} */
497    public void setEnabled(boolean value) {
498      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
499    }
500
501
502
503    /** {@inheritDoc} */
504    public String getJavaClass() {
505      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
506    }
507
508
509
510    /** {@inheritDoc} */
511    public void setJavaClass(String value) {
512      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
513    }
514
515
516
517    /** {@inheritDoc} */
518    public String getKeyManagerProvider() {
519      return impl.getPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition());
520    }
521
522
523
524    /** {@inheritDoc} */
525    public void setKeyManagerProvider(String value) {
526      impl.setPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition(), value);
527    }
528
529
530
531    /** {@inheritDoc} */
532    public InetAddress getListenAddress() {
533      return impl.getPropertyValue(INSTANCE.getListenAddressPropertyDefinition());
534    }
535
536
537
538    /** {@inheritDoc} */
539    public void setListenAddress(InetAddress value) {
540      impl.setPropertyValue(INSTANCE.getListenAddressPropertyDefinition(), value);
541    }
542
543
544
545    /** {@inheritDoc} */
546    public Integer getListenPort() {
547      return impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition());
548    }
549
550
551
552    /** {@inheritDoc} */
553    public void setListenPort(int value) {
554      impl.setPropertyValue(INSTANCE.getListenPortPropertyDefinition(), value);
555    }
556
557
558
559    /** {@inheritDoc} */
560    public int getRmiPort() {
561      return impl.getPropertyValue(INSTANCE.getRmiPortPropertyDefinition());
562    }
563
564
565
566    /** {@inheritDoc} */
567    public void setRmiPort(Integer value) {
568      impl.setPropertyValue(INSTANCE.getRmiPortPropertyDefinition(), value);
569    }
570
571
572
573    /** {@inheritDoc} */
574    public SortedSet<String> getSSLCertNickname() {
575      return impl.getPropertyValues(INSTANCE.getSSLCertNicknamePropertyDefinition());
576    }
577
578
579
580    /** {@inheritDoc} */
581    public void setSSLCertNickname(Collection<String> values) {
582      impl.setPropertyValues(INSTANCE.getSSLCertNicknamePropertyDefinition(), values);
583    }
584
585
586
587    /** {@inheritDoc} */
588    public boolean isUseSSL() {
589      return impl.getPropertyValue(INSTANCE.getUseSSLPropertyDefinition());
590    }
591
592
593
594    /** {@inheritDoc} */
595    public void setUseSSL(Boolean value) {
596      impl.setPropertyValue(INSTANCE.getUseSSLPropertyDefinition(), value);
597    }
598
599
600
601    /** {@inheritDoc} */
602    public ManagedObjectDefinition<? extends JMXConnectionHandlerCfgClient, ? extends JMXConnectionHandlerCfg> definition() {
603      return INSTANCE;
604    }
605
606
607
608    /** {@inheritDoc} */
609    public PropertyProvider properties() {
610      return impl;
611    }
612
613
614
615    /** {@inheritDoc} */
616    public void commit() throws ManagedObjectAlreadyExistsException,
617        MissingMandatoryPropertiesException, ConcurrentModificationException,
618        OperationRejectedException, LdapException {
619      impl.commit();
620    }
621
622
623
624    /** {@inheritDoc} */
625    public String toString() {
626      return impl.toString();
627    }
628  }
629
630
631
632  /**
633   * Managed object server implementation.
634   */
635  private static class JMXConnectionHandlerCfgServerImpl implements
636    JMXConnectionHandlerCfg {
637
638    /** Private implementation. */
639    private ServerManagedObject<? extends JMXConnectionHandlerCfg> impl;
640
641    /** The value of the "allowed-client" property. */
642    private final SortedSet<AddressMask> pAllowedClient;
643
644    /** The value of the "denied-client" property. */
645    private final SortedSet<AddressMask> pDeniedClient;
646
647    /** The value of the "enabled" property. */
648    private final boolean pEnabled;
649
650    /** The value of the "java-class" property. */
651    private final String pJavaClass;
652
653    /** The value of the "key-manager-provider" property. */
654    private final String pKeyManagerProvider;
655
656    /** The value of the "listen-address" property. */
657    private final InetAddress pListenAddress;
658
659    /** The value of the "listen-port" property. */
660    private final int pListenPort;
661
662    /** The value of the "rmi-port" property. */
663    private final int pRmiPort;
664
665    /** The value of the "ssl-cert-nickname" property. */
666    private final SortedSet<String> pSSLCertNickname;
667
668    /** The value of the "use-ssl" property. */
669    private final boolean pUseSSL;
670
671
672
673    /** Private constructor. */
674    private JMXConnectionHandlerCfgServerImpl(ServerManagedObject<? extends JMXConnectionHandlerCfg> impl) {
675      this.impl = impl;
676      this.pAllowedClient = impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
677      this.pDeniedClient = impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
678      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
679      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
680      this.pKeyManagerProvider = impl.getPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition());
681      this.pListenAddress = impl.getPropertyValue(INSTANCE.getListenAddressPropertyDefinition());
682      this.pListenPort = impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition());
683      this.pRmiPort = impl.getPropertyValue(INSTANCE.getRmiPortPropertyDefinition());
684      this.pSSLCertNickname = impl.getPropertyValues(INSTANCE.getSSLCertNicknamePropertyDefinition());
685      this.pUseSSL = impl.getPropertyValue(INSTANCE.getUseSSLPropertyDefinition());
686    }
687
688
689
690    /** {@inheritDoc} */
691    public void addJMXChangeListener(
692        ConfigurationChangeListener<JMXConnectionHandlerCfg> listener) {
693      impl.registerChangeListener(listener);
694    }
695
696
697
698    /** {@inheritDoc} */
699    public void removeJMXChangeListener(
700        ConfigurationChangeListener<JMXConnectionHandlerCfg> listener) {
701      impl.deregisterChangeListener(listener);
702    }
703    /** {@inheritDoc} */
704    public void addChangeListener(
705        ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
706      impl.registerChangeListener(listener);
707    }
708
709
710
711    /** {@inheritDoc} */
712    public void removeChangeListener(
713        ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
714      impl.deregisterChangeListener(listener);
715    }
716
717
718
719    /** {@inheritDoc} */
720    public SortedSet<AddressMask> getAllowedClient() {
721      return pAllowedClient;
722    }
723
724
725
726    /** {@inheritDoc} */
727    public SortedSet<AddressMask> getDeniedClient() {
728      return pDeniedClient;
729    }
730
731
732
733    /** {@inheritDoc} */
734    public boolean isEnabled() {
735      return pEnabled;
736    }
737
738
739
740    /** {@inheritDoc} */
741    public String getJavaClass() {
742      return pJavaClass;
743    }
744
745
746
747    /** {@inheritDoc} */
748    public String getKeyManagerProvider() {
749      return pKeyManagerProvider;
750    }
751
752
753
754    /**
755     * {@inheritDoc}
756     */
757    public DN getKeyManagerProviderDN() {
758      String value = getKeyManagerProvider();
759      if (value == null) return null;
760      return INSTANCE.getKeyManagerProviderPropertyDefinition().getChildDN(value);
761    }
762
763
764
765    /** {@inheritDoc} */
766    public InetAddress getListenAddress() {
767      return pListenAddress;
768    }
769
770
771
772    /** {@inheritDoc} */
773    public int getListenPort() {
774      return pListenPort;
775    }
776
777
778
779    /** {@inheritDoc} */
780    public int getRmiPort() {
781      return pRmiPort;
782    }
783
784
785
786    /** {@inheritDoc} */
787    public SortedSet<String> getSSLCertNickname() {
788      return pSSLCertNickname;
789    }
790
791
792
793    /** {@inheritDoc} */
794    public boolean isUseSSL() {
795      return pUseSSL;
796    }
797
798
799
800    /** {@inheritDoc} */
801    public Class<? extends JMXConnectionHandlerCfg> configurationClass() {
802      return JMXConnectionHandlerCfg.class;
803    }
804
805
806
807    /** {@inheritDoc} */
808    public DN dn() {
809      return impl.getDN();
810    }
811
812
813
814    /** {@inheritDoc} */
815    public String toString() {
816      return impl.toString();
817    }
818  }
819}