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}