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