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.DefaultBehaviorProvider;
044 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
045 import org.opends.server.admin.EnumPropertyDefinition;
046 import org.opends.server.admin.IntegerPropertyDefinition;
047 import org.opends.server.admin.IPAddressMaskPropertyDefinition;
048 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
049 import org.opends.server.admin.ManagedObjectDefinition;
050 import org.opends.server.admin.PropertyOption;
051 import org.opends.server.admin.PropertyProvider;
052 import org.opends.server.admin.server.ConfigurationChangeListener;
053 import org.opends.server.admin.server.ServerManagedObject;
054 import org.opends.server.admin.std.client.SNMPConnectionHandlerCfgClient;
055 import org.opends.server.admin.std.server.ConnectionHandlerCfg;
056 import org.opends.server.admin.std.server.SNMPConnectionHandlerCfg;
057 import org.opends.server.admin.StringPropertyDefinition;
058 import org.opends.server.admin.Tag;
059 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
060 import org.opends.server.types.AddressMask;
061 import org.opends.server.types.DN;
062
063
064
065 /**
066 * An interface for querying the SNMP Connection Handler managed
067 * object definition meta information.
068 * <p>
069 * The SNMP Connection Handler can be used to process SNMP requests to
070 * retrieve monitoring information described by the MIB 2605. Supported
071 * protocol are SNMP V1, V2c and V3.
072 */
073 public final class SNMPConnectionHandlerCfgDefn extends ManagedObjectDefinition<SNMPConnectionHandlerCfgClient, SNMPConnectionHandlerCfg> {
074
075 // The singleton configuration definition instance.
076 private static final SNMPConnectionHandlerCfgDefn INSTANCE = new SNMPConnectionHandlerCfgDefn();
077
078
079
080 /**
081 * Defines the set of permissable values for the "security-level" property.
082 * <p>
083 * Specifies the type of security level : NoAuthNoPriv : No security
084 * mechanisms activated, AuthNoPriv : Authentication activated with
085 * no privacy, AuthPriv : Authentication with privacy activated. This
086 * property id required for SNMP V3 security configuration.
087 */
088 public static enum SecurityLevel {
089
090 /**
091 * Authentication activated with no privacy.
092 */
093 AUTHNOPRIV("authnopriv"),
094
095
096
097 /**
098 * Authentication with privacy activated.
099 */
100 AUTHPRIV("authpriv"),
101
102
103
104 /**
105 * No security mechanisms activated.
106 */
107 NOAUTHNOPRIV("noauthnopriv");
108
109
110
111 // String representation of the value.
112 private final String name;
113
114
115
116 // Private constructor.
117 private SecurityLevel(String name) { this.name = name; }
118
119
120
121 /**
122 * {@inheritDoc}
123 */
124 public String toString() { return name; }
125
126 }
127
128
129
130 // The "allowed-manager" property definition.
131 private static final StringPropertyDefinition PD_ALLOWED_MANAGER;
132
133
134
135 // The "allowed-user" property definition.
136 private static final StringPropertyDefinition PD_ALLOWED_USER;
137
138
139
140 // The "community" property definition.
141 private static final StringPropertyDefinition PD_COMMUNITY;
142
143
144
145 // The "java-class" property definition.
146 private static final ClassPropertyDefinition PD_JAVA_CLASS;
147
148
149
150 // The "listen-port" property definition.
151 private static final IntegerPropertyDefinition PD_LISTEN_PORT;
152
153
154
155 // The "opendmk-jarfile" property definition.
156 private static final StringPropertyDefinition PD_OPENDMK_JARFILE;
157
158
159
160 // The "registered-mbean" property definition.
161 private static final BooleanPropertyDefinition PD_REGISTERED_MBEAN;
162
163
164
165 // The "security-agent-file" property definition.
166 private static final StringPropertyDefinition PD_SECURITY_AGENT_FILE;
167
168
169
170 // The "security-level" property definition.
171 private static final EnumPropertyDefinition<SecurityLevel> PD_SECURITY_LEVEL;
172
173
174
175 // The "trap-port" property definition.
176 private static final IntegerPropertyDefinition PD_TRAP_PORT;
177
178
179
180 // The "traps-community" property definition.
181 private static final StringPropertyDefinition PD_TRAPS_COMMUNITY;
182
183
184
185 // The "traps-destination" property definition.
186 private static final StringPropertyDefinition PD_TRAPS_DESTINATION;
187
188
189
190 // Build the "allowed-manager" property definition.
191 static {
192 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "allowed-manager");
193 builder.setOption(PropertyOption.MULTI_VALUED);
194 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allowed-manager"));
195 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("*");
196 builder.setDefaultBehaviorProvider(provider);
197 PD_ALLOWED_MANAGER = builder.getInstance();
198 INSTANCE.registerPropertyDefinition(PD_ALLOWED_MANAGER);
199 }
200
201
202
203 // Build the "allowed-user" property definition.
204 static {
205 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "allowed-user");
206 builder.setOption(PropertyOption.MULTI_VALUED);
207 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allowed-user"));
208 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("*");
209 builder.setDefaultBehaviorProvider(provider);
210 PD_ALLOWED_USER = builder.getInstance();
211 INSTANCE.registerPropertyDefinition(PD_ALLOWED_USER);
212 }
213
214
215
216 // Build the "community" property definition.
217 static {
218 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "community");
219 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "community"));
220 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("OpenDS");
221 builder.setDefaultBehaviorProvider(provider);
222 PD_COMMUNITY = builder.getInstance();
223 INSTANCE.registerPropertyDefinition(PD_COMMUNITY);
224 }
225
226
227
228 // Build the "java-class" property definition.
229 static {
230 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
231 builder.setOption(PropertyOption.MANDATORY);
232 builder.setOption(PropertyOption.ADVANCED);
233 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
234 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.snmp.SNMPConnectionHandler");
235 builder.setDefaultBehaviorProvider(provider);
236 builder.addInstanceOf("org.opends.server.api.ConnectionHandler");
237 PD_JAVA_CLASS = builder.getInstance();
238 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
239 }
240
241
242
243 // Build the "listen-port" property definition.
244 static {
245 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "listen-port");
246 builder.setOption(PropertyOption.MANDATORY);
247 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "listen-port"));
248 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>());
249 builder.setUpperLimit(65535);
250 builder.setLowerLimit(1);
251 PD_LISTEN_PORT = builder.getInstance();
252 INSTANCE.registerPropertyDefinition(PD_LISTEN_PORT);
253 }
254
255
256
257 // Build the "opendmk-jarfile" property definition.
258 static {
259 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "opendmk-jarfile");
260 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "opendmk-jarfile"));
261 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
262 PD_OPENDMK_JARFILE = builder.getInstance();
263 INSTANCE.registerPropertyDefinition(PD_OPENDMK_JARFILE);
264 }
265
266
267
268 // Build the "registered-mbean" property definition.
269 static {
270 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "registered-mbean");
271 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "registered-mbean"));
272 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
273 builder.setDefaultBehaviorProvider(provider);
274 PD_REGISTERED_MBEAN = builder.getInstance();
275 INSTANCE.registerPropertyDefinition(PD_REGISTERED_MBEAN);
276 }
277
278
279
280 // Build the "security-agent-file" property definition.
281 static {
282 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "security-agent-file");
283 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "security-agent-file"));
284 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("config/snmp/security/opends-snmp.security");
285 builder.setDefaultBehaviorProvider(provider);
286 PD_SECURITY_AGENT_FILE = builder.getInstance();
287 INSTANCE.registerPropertyDefinition(PD_SECURITY_AGENT_FILE);
288 }
289
290
291
292 // Build the "security-level" property definition.
293 static {
294 EnumPropertyDefinition.Builder<SecurityLevel> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "security-level");
295 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "security-level"));
296 DefaultBehaviorProvider<SecurityLevel> provider = new DefinedDefaultBehaviorProvider<SecurityLevel>("authnopriv");
297 builder.setDefaultBehaviorProvider(provider);
298 builder.setEnumClass(SecurityLevel.class);
299 PD_SECURITY_LEVEL = builder.getInstance();
300 INSTANCE.registerPropertyDefinition(PD_SECURITY_LEVEL);
301 }
302
303
304
305 // Build the "trap-port" property definition.
306 static {
307 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "trap-port");
308 builder.setOption(PropertyOption.MANDATORY);
309 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "trap-port"));
310 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>());
311 PD_TRAP_PORT = builder.getInstance();
312 INSTANCE.registerPropertyDefinition(PD_TRAP_PORT);
313 }
314
315
316
317 // Build the "traps-community" property definition.
318 static {
319 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "traps-community");
320 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "traps-community"));
321 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("OpenDS");
322 builder.setDefaultBehaviorProvider(provider);
323 PD_TRAPS_COMMUNITY = builder.getInstance();
324 INSTANCE.registerPropertyDefinition(PD_TRAPS_COMMUNITY);
325 }
326
327
328
329 // Build the "traps-destination" property definition.
330 static {
331 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "traps-destination");
332 builder.setOption(PropertyOption.MULTI_VALUED);
333 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "traps-destination"));
334 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "traps-destination"));
335 PD_TRAPS_DESTINATION = builder.getInstance();
336 INSTANCE.registerPropertyDefinition(PD_TRAPS_DESTINATION);
337 }
338
339
340
341 // Register the tags associated with this managed object definition.
342 static {
343 INSTANCE.registerTag(Tag.valueOf("core-server"));
344 }
345
346
347
348 /**
349 * Get the SNMP Connection Handler configuration definition
350 * singleton.
351 *
352 * @return Returns the SNMP Connection Handler configuration
353 * definition singleton.
354 */
355 public static SNMPConnectionHandlerCfgDefn getInstance() {
356 return INSTANCE;
357 }
358
359
360
361 /**
362 * Private constructor.
363 */
364 private SNMPConnectionHandlerCfgDefn() {
365 super("snmp-connection-handler", ConnectionHandlerCfgDefn.getInstance());
366 }
367
368
369
370 /**
371 * {@inheritDoc}
372 */
373 public SNMPConnectionHandlerCfgClient createClientConfiguration(
374 ManagedObject<? extends SNMPConnectionHandlerCfgClient> impl) {
375 return new SNMPConnectionHandlerCfgClientImpl(impl);
376 }
377
378
379
380 /**
381 * {@inheritDoc}
382 */
383 public SNMPConnectionHandlerCfg createServerConfiguration(
384 ServerManagedObject<? extends SNMPConnectionHandlerCfg> impl) {
385 return new SNMPConnectionHandlerCfgServerImpl(impl);
386 }
387
388
389
390 /**
391 * {@inheritDoc}
392 */
393 public Class<SNMPConnectionHandlerCfg> getServerConfigurationClass() {
394 return SNMPConnectionHandlerCfg.class;
395 }
396
397
398
399 /**
400 * Get the "allowed-client" property definition.
401 * <p>
402 * Specifies a set of address masks that determines the addresses of
403 * the clients that are allowed to establish connections to this
404 * connection handler.
405 *
406 * @return Returns the "allowed-client" property definition.
407 */
408 public IPAddressMaskPropertyDefinition getAllowedClientPropertyDefinition() {
409 return ConnectionHandlerCfgDefn.getInstance().getAllowedClientPropertyDefinition();
410 }
411
412
413
414 /**
415 * Get the "allowed-manager" property definition.
416 * <p>
417 * Specifies the hosts of the managers to be granted the access
418 * rights. This property is required for SNMP v1 and v2 security
419 * configuration. An asterik (*) opens access to all managers.
420 *
421 * @return Returns the "allowed-manager" property definition.
422 */
423 public StringPropertyDefinition getAllowedManagerPropertyDefinition() {
424 return PD_ALLOWED_MANAGER;
425 }
426
427
428
429 /**
430 * Get the "allowed-user" property definition.
431 * <p>
432 * Specifies the users to be granted the access rights. This
433 * property is required for SNMP v3 security configuration. An
434 * asterik (*) opens access to all users.
435 *
436 * @return Returns the "allowed-user" property definition.
437 */
438 public StringPropertyDefinition getAllowedUserPropertyDefinition() {
439 return PD_ALLOWED_USER;
440 }
441
442
443
444 /**
445 * Get the "community" property definition.
446 * <p>
447 * Specifies the v1,v2 community or the v3 context name allowed to
448 * access the MIB 2605 monitoring information or the USM MIB. The
449 * mapping between "community" and "context name" is set.
450 *
451 * @return Returns the "community" property definition.
452 */
453 public StringPropertyDefinition getCommunityPropertyDefinition() {
454 return PD_COMMUNITY;
455 }
456
457
458
459 /**
460 * Get the "denied-client" property definition.
461 * <p>
462 * Specifies a set of address masks that determines the addresses of
463 * the clients that are not allowed to establish connections to this
464 * connection handler.
465 * <p>
466 * If both allowed and denied client masks are defined and a client
467 * connection matches one or more masks in both lists, then the
468 * connection is denied. If only a denied list is specified, then any
469 * client not matching a mask in that list is allowed.
470 *
471 * @return Returns the "denied-client" property definition.
472 */
473 public IPAddressMaskPropertyDefinition getDeniedClientPropertyDefinition() {
474 return ConnectionHandlerCfgDefn.getInstance().getDeniedClientPropertyDefinition();
475 }
476
477
478
479 /**
480 * Get the "enabled" property definition.
481 * <p>
482 * Indicates whether the SNMP Connection Handler is enabled.
483 *
484 * @return Returns the "enabled" property definition.
485 */
486 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
487 return ConnectionHandlerCfgDefn.getInstance().getEnabledPropertyDefinition();
488 }
489
490
491
492 /**
493 * Get the "java-class" property definition.
494 * <p>
495 * Specifies the fully-qualified name of the Java class that
496 * provides the SNMP Connection Handler implementation.
497 *
498 * @return Returns the "java-class" property definition.
499 */
500 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
501 return PD_JAVA_CLASS;
502 }
503
504
505
506 /**
507 * Get the "listen-port" property definition.
508 * <p>
509 * Specifies the port number on which the SNMP Connection Handler
510 * will listen for connections from clients.
511 * <p>
512 * Only a single port number may be provided.
513 *
514 * @return Returns the "listen-port" property definition.
515 */
516 public IntegerPropertyDefinition getListenPortPropertyDefinition() {
517 return PD_LISTEN_PORT;
518 }
519
520
521
522 /**
523 * Get the "opendmk-jarfile" property definition.
524 * <p>
525 * Indicates the OpenDMK runtime jar file location
526 *
527 * @return Returns the "opendmk-jarfile" property definition.
528 */
529 public StringPropertyDefinition getOpendmkJarfilePropertyDefinition() {
530 return PD_OPENDMK_JARFILE;
531 }
532
533
534
535 /**
536 * Get the "registered-mbean" property definition.
537 * <p>
538 * Indicates whether the SNMP objects have to be registered in the
539 * Directory Server MBeanServer or not allowing to access SNMP
540 * Objects with RMI connector if enabled.
541 *
542 * @return Returns the "registered-mbean" property definition.
543 */
544 public BooleanPropertyDefinition getRegisteredMbeanPropertyDefinition() {
545 return PD_REGISTERED_MBEAN;
546 }
547
548
549
550 /**
551 * Get the "security-agent-file" property definition.
552 * <p>
553 * Specifies the USM security configuration to receive authenticated
554 * only SNMP requests.
555 *
556 * @return Returns the "security-agent-file" property definition.
557 */
558 public StringPropertyDefinition getSecurityAgentFilePropertyDefinition() {
559 return PD_SECURITY_AGENT_FILE;
560 }
561
562
563
564 /**
565 * Get the "security-level" property definition.
566 * <p>
567 * Specifies the type of security level : NoAuthNoPriv : No security
568 * mechanisms activated, AuthNoPriv : Authentication activated with
569 * no privacy, AuthPriv : Authentication with privacy activated. This
570 * property id required for SNMP V3 security configuration.
571 *
572 * @return Returns the "security-level" property definition.
573 */
574 public EnumPropertyDefinition<SecurityLevel> getSecurityLevelPropertyDefinition() {
575 return PD_SECURITY_LEVEL;
576 }
577
578
579
580 /**
581 * Get the "trap-port" property definition.
582 * <p>
583 * Specifies the port to use to send SNMP Traps.
584 *
585 * @return Returns the "trap-port" property definition.
586 */
587 public IntegerPropertyDefinition getTrapPortPropertyDefinition() {
588 return PD_TRAP_PORT;
589 }
590
591
592
593 /**
594 * Get the "traps-community" property definition.
595 * <p>
596 * Specifies the community string that must be include in the traps
597 * sent to define managers (trap-destinations). This property is used
598 * in the context of SNMP v1, v2 and v3.
599 *
600 * @return Returns the "traps-community" property definition.
601 */
602 public StringPropertyDefinition getTrapsCommunityPropertyDefinition() {
603 return PD_TRAPS_COMMUNITY;
604 }
605
606
607
608 /**
609 * Get the "traps-destination" property definition.
610 * <p>
611 * Specifies the hosts to which V1 traps will be sent. V1 Traps are
612 * sent to every host listed.
613 * <p>
614 * If this list is empty, V1 traps are sent to "localhost". Each
615 * host in the list must be identifed by its name or complete IP
616 * Addess.
617 *
618 * @return Returns the "traps-destination" property definition.
619 */
620 public StringPropertyDefinition getTrapsDestinationPropertyDefinition() {
621 return PD_TRAPS_DESTINATION;
622 }
623
624
625
626 /**
627 * Managed object client implementation.
628 */
629 private static class SNMPConnectionHandlerCfgClientImpl implements
630 SNMPConnectionHandlerCfgClient {
631
632 // Private implementation.
633 private ManagedObject<? extends SNMPConnectionHandlerCfgClient> impl;
634
635
636
637 // Private constructor.
638 private SNMPConnectionHandlerCfgClientImpl(
639 ManagedObject<? extends SNMPConnectionHandlerCfgClient> impl) {
640 this.impl = impl;
641 }
642
643
644
645 /**
646 * {@inheritDoc}
647 */
648 public SortedSet<AddressMask> getAllowedClient() {
649 return impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
650 }
651
652
653
654 /**
655 * {@inheritDoc}
656 */
657 public void setAllowedClient(Collection<AddressMask> values) {
658 impl.setPropertyValues(INSTANCE.getAllowedClientPropertyDefinition(), values);
659 }
660
661
662
663 /**
664 * {@inheritDoc}
665 */
666 public SortedSet<String> getAllowedManager() {
667 return impl.getPropertyValues(INSTANCE.getAllowedManagerPropertyDefinition());
668 }
669
670
671
672 /**
673 * {@inheritDoc}
674 */
675 public void setAllowedManager(Collection<String> values) {
676 impl.setPropertyValues(INSTANCE.getAllowedManagerPropertyDefinition(), values);
677 }
678
679
680
681 /**
682 * {@inheritDoc}
683 */
684 public SortedSet<String> getAllowedUser() {
685 return impl.getPropertyValues(INSTANCE.getAllowedUserPropertyDefinition());
686 }
687
688
689
690 /**
691 * {@inheritDoc}
692 */
693 public void setAllowedUser(Collection<String> values) {
694 impl.setPropertyValues(INSTANCE.getAllowedUserPropertyDefinition(), values);
695 }
696
697
698
699 /**
700 * {@inheritDoc}
701 */
702 public String getCommunity() {
703 return impl.getPropertyValue(INSTANCE.getCommunityPropertyDefinition());
704 }
705
706
707
708 /**
709 * {@inheritDoc}
710 */
711 public void setCommunity(String value) {
712 impl.setPropertyValue(INSTANCE.getCommunityPropertyDefinition(), value);
713 }
714
715
716
717 /**
718 * {@inheritDoc}
719 */
720 public SortedSet<AddressMask> getDeniedClient() {
721 return impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
722 }
723
724
725
726 /**
727 * {@inheritDoc}
728 */
729 public void setDeniedClient(Collection<AddressMask> values) {
730 impl.setPropertyValues(INSTANCE.getDeniedClientPropertyDefinition(), values);
731 }
732
733
734
735 /**
736 * {@inheritDoc}
737 */
738 public Boolean isEnabled() {
739 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
740 }
741
742
743
744 /**
745 * {@inheritDoc}
746 */
747 public void setEnabled(boolean value) {
748 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
749 }
750
751
752
753 /**
754 * {@inheritDoc}
755 */
756 public String getJavaClass() {
757 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
758 }
759
760
761
762 /**
763 * {@inheritDoc}
764 */
765 public void setJavaClass(String value) {
766 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
767 }
768
769
770
771 /**
772 * {@inheritDoc}
773 */
774 public Integer getListenPort() {
775 return impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition());
776 }
777
778
779
780 /**
781 * {@inheritDoc}
782 */
783 public void setListenPort(int value) {
784 impl.setPropertyValue(INSTANCE.getListenPortPropertyDefinition(), value);
785 }
786
787
788
789 /**
790 * {@inheritDoc}
791 */
792 public String getOpendmkJarfile() {
793 return impl.getPropertyValue(INSTANCE.getOpendmkJarfilePropertyDefinition());
794 }
795
796
797
798 /**
799 * {@inheritDoc}
800 */
801 public void setOpendmkJarfile(String value) {
802 impl.setPropertyValue(INSTANCE.getOpendmkJarfilePropertyDefinition(), value);
803 }
804
805
806
807 /**
808 * {@inheritDoc}
809 */
810 public boolean isRegisteredMbean() {
811 return impl.getPropertyValue(INSTANCE.getRegisteredMbeanPropertyDefinition());
812 }
813
814
815
816 /**
817 * {@inheritDoc}
818 */
819 public void setRegisteredMbean(Boolean value) {
820 impl.setPropertyValue(INSTANCE.getRegisteredMbeanPropertyDefinition(), value);
821 }
822
823
824
825 /**
826 * {@inheritDoc}
827 */
828 public String getSecurityAgentFile() {
829 return impl.getPropertyValue(INSTANCE.getSecurityAgentFilePropertyDefinition());
830 }
831
832
833
834 /**
835 * {@inheritDoc}
836 */
837 public void setSecurityAgentFile(String value) {
838 impl.setPropertyValue(INSTANCE.getSecurityAgentFilePropertyDefinition(), value);
839 }
840
841
842
843 /**
844 * {@inheritDoc}
845 */
846 public SecurityLevel getSecurityLevel() {
847 return impl.getPropertyValue(INSTANCE.getSecurityLevelPropertyDefinition());
848 }
849
850
851
852 /**
853 * {@inheritDoc}
854 */
855 public void setSecurityLevel(SecurityLevel value) {
856 impl.setPropertyValue(INSTANCE.getSecurityLevelPropertyDefinition(), value);
857 }
858
859
860
861 /**
862 * {@inheritDoc}
863 */
864 public Integer getTrapPort() {
865 return impl.getPropertyValue(INSTANCE.getTrapPortPropertyDefinition());
866 }
867
868
869
870 /**
871 * {@inheritDoc}
872 */
873 public void setTrapPort(int value) {
874 impl.setPropertyValue(INSTANCE.getTrapPortPropertyDefinition(), value);
875 }
876
877
878
879 /**
880 * {@inheritDoc}
881 */
882 public String getTrapsCommunity() {
883 return impl.getPropertyValue(INSTANCE.getTrapsCommunityPropertyDefinition());
884 }
885
886
887
888 /**
889 * {@inheritDoc}
890 */
891 public void setTrapsCommunity(String value) {
892 impl.setPropertyValue(INSTANCE.getTrapsCommunityPropertyDefinition(), value);
893 }
894
895
896
897 /**
898 * {@inheritDoc}
899 */
900 public SortedSet<String> getTrapsDestination() {
901 return impl.getPropertyValues(INSTANCE.getTrapsDestinationPropertyDefinition());
902 }
903
904
905
906 /**
907 * {@inheritDoc}
908 */
909 public void setTrapsDestination(Collection<String> values) {
910 impl.setPropertyValues(INSTANCE.getTrapsDestinationPropertyDefinition(), values);
911 }
912
913
914
915 /**
916 * {@inheritDoc}
917 */
918 public ManagedObjectDefinition<? extends SNMPConnectionHandlerCfgClient, ? extends SNMPConnectionHandlerCfg> definition() {
919 return INSTANCE;
920 }
921
922
923
924 /**
925 * {@inheritDoc}
926 */
927 public PropertyProvider properties() {
928 return impl;
929 }
930
931
932
933 /**
934 * {@inheritDoc}
935 */
936 public void commit() throws ManagedObjectAlreadyExistsException,
937 MissingMandatoryPropertiesException, ConcurrentModificationException,
938 OperationRejectedException, AuthorizationException,
939 CommunicationException {
940 impl.commit();
941 }
942
943 }
944
945
946
947 /**
948 * Managed object server implementation.
949 */
950 private static class SNMPConnectionHandlerCfgServerImpl implements
951 SNMPConnectionHandlerCfg {
952
953 // Private implementation.
954 private ServerManagedObject<? extends SNMPConnectionHandlerCfg> impl;
955
956 // The value of the "allowed-client" property.
957 private final SortedSet<AddressMask> pAllowedClient;
958
959 // The value of the "allowed-manager" property.
960 private final SortedSet<String> pAllowedManager;
961
962 // The value of the "allowed-user" property.
963 private final SortedSet<String> pAllowedUser;
964
965 // The value of the "community" property.
966 private final String pCommunity;
967
968 // The value of the "denied-client" property.
969 private final SortedSet<AddressMask> pDeniedClient;
970
971 // The value of the "enabled" property.
972 private final boolean pEnabled;
973
974 // The value of the "java-class" property.
975 private final String pJavaClass;
976
977 // The value of the "listen-port" property.
978 private final int pListenPort;
979
980 // The value of the "opendmk-jarfile" property.
981 private final String pOpendmkJarfile;
982
983 // The value of the "registered-mbean" property.
984 private final boolean pRegisteredMbean;
985
986 // The value of the "security-agent-file" property.
987 private final String pSecurityAgentFile;
988
989 // The value of the "security-level" property.
990 private final SecurityLevel pSecurityLevel;
991
992 // The value of the "trap-port" property.
993 private final int pTrapPort;
994
995 // The value of the "traps-community" property.
996 private final String pTrapsCommunity;
997
998 // The value of the "traps-destination" property.
999 private final SortedSet<String> pTrapsDestination;
1000
1001
1002
1003 // Private constructor.
1004 private SNMPConnectionHandlerCfgServerImpl(ServerManagedObject<? extends SNMPConnectionHandlerCfg> impl) {
1005 this.impl = impl;
1006 this.pAllowedClient = impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition());
1007 this.pAllowedManager = impl.getPropertyValues(INSTANCE.getAllowedManagerPropertyDefinition());
1008 this.pAllowedUser = impl.getPropertyValues(INSTANCE.getAllowedUserPropertyDefinition());
1009 this.pCommunity = impl.getPropertyValue(INSTANCE.getCommunityPropertyDefinition());
1010 this.pDeniedClient = impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition());
1011 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
1012 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1013 this.pListenPort = impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition());
1014 this.pOpendmkJarfile = impl.getPropertyValue(INSTANCE.getOpendmkJarfilePropertyDefinition());
1015 this.pRegisteredMbean = impl.getPropertyValue(INSTANCE.getRegisteredMbeanPropertyDefinition());
1016 this.pSecurityAgentFile = impl.getPropertyValue(INSTANCE.getSecurityAgentFilePropertyDefinition());
1017 this.pSecurityLevel = impl.getPropertyValue(INSTANCE.getSecurityLevelPropertyDefinition());
1018 this.pTrapPort = impl.getPropertyValue(INSTANCE.getTrapPortPropertyDefinition());
1019 this.pTrapsCommunity = impl.getPropertyValue(INSTANCE.getTrapsCommunityPropertyDefinition());
1020 this.pTrapsDestination = impl.getPropertyValues(INSTANCE.getTrapsDestinationPropertyDefinition());
1021 }
1022
1023
1024
1025 /**
1026 * {@inheritDoc}
1027 */
1028 public void addSNMPChangeListener(
1029 ConfigurationChangeListener<SNMPConnectionHandlerCfg> listener) {
1030 impl.registerChangeListener(listener);
1031 }
1032
1033
1034
1035 /**
1036 * {@inheritDoc}
1037 */
1038 public void removeSNMPChangeListener(
1039 ConfigurationChangeListener<SNMPConnectionHandlerCfg> listener) {
1040 impl.deregisterChangeListener(listener);
1041 }
1042 /**
1043 * {@inheritDoc}
1044 */
1045 public void addChangeListener(
1046 ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
1047 impl.registerChangeListener(listener);
1048 }
1049
1050
1051
1052 /**
1053 * {@inheritDoc}
1054 */
1055 public void removeChangeListener(
1056 ConfigurationChangeListener<ConnectionHandlerCfg> listener) {
1057 impl.deregisterChangeListener(listener);
1058 }
1059
1060
1061
1062 /**
1063 * {@inheritDoc}
1064 */
1065 public SortedSet<AddressMask> getAllowedClient() {
1066 return pAllowedClient;
1067 }
1068
1069
1070
1071 /**
1072 * {@inheritDoc}
1073 */
1074 public SortedSet<String> getAllowedManager() {
1075 return pAllowedManager;
1076 }
1077
1078
1079
1080 /**
1081 * {@inheritDoc}
1082 */
1083 public SortedSet<String> getAllowedUser() {
1084 return pAllowedUser;
1085 }
1086
1087
1088
1089 /**
1090 * {@inheritDoc}
1091 */
1092 public String getCommunity() {
1093 return pCommunity;
1094 }
1095
1096
1097
1098 /**
1099 * {@inheritDoc}
1100 */
1101 public SortedSet<AddressMask> getDeniedClient() {
1102 return pDeniedClient;
1103 }
1104
1105
1106
1107 /**
1108 * {@inheritDoc}
1109 */
1110 public boolean isEnabled() {
1111 return pEnabled;
1112 }
1113
1114
1115
1116 /**
1117 * {@inheritDoc}
1118 */
1119 public String getJavaClass() {
1120 return pJavaClass;
1121 }
1122
1123
1124
1125 /**
1126 * {@inheritDoc}
1127 */
1128 public int getListenPort() {
1129 return pListenPort;
1130 }
1131
1132
1133
1134 /**
1135 * {@inheritDoc}
1136 */
1137 public String getOpendmkJarfile() {
1138 return pOpendmkJarfile;
1139 }
1140
1141
1142
1143 /**
1144 * {@inheritDoc}
1145 */
1146 public boolean isRegisteredMbean() {
1147 return pRegisteredMbean;
1148 }
1149
1150
1151
1152 /**
1153 * {@inheritDoc}
1154 */
1155 public String getSecurityAgentFile() {
1156 return pSecurityAgentFile;
1157 }
1158
1159
1160
1161 /**
1162 * {@inheritDoc}
1163 */
1164 public SecurityLevel getSecurityLevel() {
1165 return pSecurityLevel;
1166 }
1167
1168
1169
1170 /**
1171 * {@inheritDoc}
1172 */
1173 public int getTrapPort() {
1174 return pTrapPort;
1175 }
1176
1177
1178
1179 /**
1180 * {@inheritDoc}
1181 */
1182 public String getTrapsCommunity() {
1183 return pTrapsCommunity;
1184 }
1185
1186
1187
1188 /**
1189 * {@inheritDoc}
1190 */
1191 public SortedSet<String> getTrapsDestination() {
1192 return pTrapsDestination;
1193 }
1194
1195
1196
1197 /**
1198 * {@inheritDoc}
1199 */
1200 public Class<? extends SNMPConnectionHandlerCfg> configurationClass() {
1201 return SNMPConnectionHandlerCfg.class;
1202 }
1203
1204
1205
1206 /**
1207 * {@inheritDoc}
1208 */
1209 public DN dn() {
1210 return impl.getDN();
1211 }
1212
1213 }
1214 }