001 /*
002 * Copyright 2008-2015 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2015 UnboundID Corp.
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021 package com.unboundid.ldap.sdk.unboundidds.monitors;
022
023
024
025 import java.util.ArrayList;
026 import java.util.Collections;
027 import java.util.LinkedHashMap;
028 import java.util.List;
029 import java.util.Map;
030
031 import com.unboundid.ldap.sdk.Entry;
032 import com.unboundid.util.NotMutable;
033 import com.unboundid.util.ThreadSafety;
034 import com.unboundid.util.ThreadSafetyLevel;
035
036 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
037
038
039
040 /**
041 * <BLOCKQUOTE>
042 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID
043 * LDAP SDK for Java. It is not available for use in applications that
044 * include only the Standard Edition of the LDAP SDK, and is not supported for
045 * use in conjunction with non-UnboundID products.
046 * </BLOCKQUOTE>
047 * This class defines a monitor entry that provides information about the system
048 * and JVM on which the Directory Server is running. In particular, the
049 * information that may be available includes:
050 * <UL>
051 * <LI>The name of the operating system on which the server is running.</LI>
052 * <LI>The number of CPUs available to the JVM.</LI>
053 * <LI>The Java classpath in use by the server.</LI>
054 * <LI>The amount of memory currently used by the JVM.</LI>
055 * <LI>The maximum amount of memory that the JVM will be allowed to use.</LI>
056 * <LI>The amount of memory held by the JVM that is marked as "free" and can
057 * be used to allocate new objects.</LI>
058 * <LI>The hostname for the underlying system.</LI>
059 * <LI>The location in which the server is installed on the
060 * underlying system.</LI>
061 * <LI>The current working directory for the server process.</LI>
062 * <LI>The path to the Java installation being used to run the server.</LI>
063 * <LI>The vendor that provides the Java installation being used to run the
064 * server.</LI>
065 * <LI>The Java version string for the Java installation being used to run
066 * the server.</LI>
067 * <LI>The vendor that provides the JVM being used by the Java installation
068 * being used to run the server.</LI>
069 * <LI>The JVM version string for the Java installation being used to run the
070 * server.</LI>
071 * <LI>The JVM architecture data model (i.e., whether it is a 32-bit or 64-bit
072 * JVM).</LI>
073 * <LI>The arguments provided to the JVM when running the server.</LI>
074 * </UL>
075 * The server should present at most one system info monitor entry. It can be
076 * retrieved using the {@link MonitorManager#getSystemInfoMonitorEntry} method.
077 * This entry provides specific methods for accessing this system information
078 * (e.g., the {@link SystemInfoMonitorEntry#getOperatingSystem}
079 * method can be used to retrieve the name of the operating system).
080 * Alternately, this information may be accessed using the generic API. See the
081 * {@link MonitorManager} class documentation for an example that demonstrates
082 * the use of the generic API for accessing monitor data.
083 */
084 @NotMutable()
085 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
086 public final class SystemInfoMonitorEntry
087 extends MonitorEntry
088 {
089 /**
090 * The structural object class used in system info monitor entries.
091 */
092 static final String SYSTEM_INFO_MONITOR_OC =
093 "ds-system-info-monitor-entry";
094
095
096
097 /**
098 * The name of the attribute that provides the number of CPUs available to the
099 * JVM.
100 */
101 private static final String ATTR_AVAILABLE_CPUS = "availableCPUs";
102
103
104
105 /**
106 * The name of the attribute that provides the server Java classpath.
107 */
108 private static final String ATTR_CLASSPATH = "classPath";
109
110
111
112 /**
113 * The name of the attribute that provides the environment variables defined
114 * for the server process.
115 */
116 private static final String ATTR_ENVIRONMENT_VARIABLE = "environmentVariable";
117
118
119
120 /**
121 * The name of the attribute that provides the amount of free memory within
122 * the JVM.
123 */
124 private static final String ATTR_FREE_MEMORY = "freeUsedMemory";
125
126
127
128 /**
129 * The name of the attribute that provides the system hostname.
130 */
131 private static final String ATTR_HOSTNAME = "systemName";
132
133
134
135 /**
136 * The name of the attribute that provides the server instance root.
137 */
138 private static final String ATTR_INSTANCE_ROOT = "instanceRoot";
139
140
141
142 /**
143 * The name of the attribute that provides the server Java home.
144 */
145 private static final String ATTR_JAVA_HOME = "javaHome";
146
147
148
149 /**
150 * The name of the attribute that provides the server Java vendor.
151 */
152 private static final String ATTR_JAVA_VENDOR = "javaVendor";
153
154
155
156 /**
157 * The name of the attribute that provides the server Java version.
158 */
159 private static final String ATTR_JAVA_VERSION = "javaVersion";
160
161
162
163 /**
164 * The name of the attribute that provides the server JVM architecture (e.g.,
165 * 32-bit / 64-bit).
166 */
167 private static final String ATTR_JVM_ARCHITECTURE = "jvmArchitecture";
168
169
170
171 /**
172 * The name of the attribute that provides the set of arguments provided when
173 * starting the JVM.
174 */
175 private static final String ATTR_JVM_ARGUMENTS = "jvmArguments";
176
177
178
179 /**
180 * The name of the attribute that provides the process ID of the JVM in which
181 * the server is running.
182 */
183 private static final String ATTR_JVM_PID = "jvmPID";
184
185
186
187 /**
188 * The name of the attribute that provides the server JVM vendor.
189 */
190 private static final String ATTR_JVM_VENDOR = "jvmVendor";
191
192
193
194 /**
195 * The name of the attribute that provides the server JVM version.
196 */
197 private static final String ATTR_JVM_VERSION = "jvmVersion";
198
199
200
201 /**
202 * The name of the attribute that provides the maximum amount of memory
203 * available to the JVM.
204 */
205 private static final String ATTR_MAX_MEMORY = "maxMemory";
206
207
208
209 /**
210 * The name of the attribute that provides information about the server's
211 * operating system.
212 */
213 private static final String ATTR_OPERATING_SYSTEM = "operatingSystem";
214
215
216
217 /**
218 * The name of the attribute that provides the name of the default SSL context
219 * protocol that has been selected by the server.
220 */
221 private static final String ATTR_SSL_CONTEXT_PROTOCOL = "sslContextProtocol";
222
223
224
225 /**
226 * The name of the attribute that provides the set of system properties
227 * defined in the JVM.
228 */
229 private static final String ATTR_SYSTEM_PROPERTY = "systemProperty";
230
231
232
233 /**
234 * The name of the attribute that provides the amount of memory currently used
235 * by the JVM.
236 */
237 private static final String ATTR_USED_MEMORY = "usedMemory";
238
239
240
241 /**
242 * The name of the attribute that provides the name of the user as whom the
243 * server is running.
244 */
245 private static final String ATTR_USER_NAME = "userName";
246
247
248
249 /**
250 * The name of the attribute that provides the server working directory.
251 */
252 private static final String ATTR_WORKING_DIRECTORY = "workingDirectory";
253
254
255
256 /**
257 * The serial version UID for this serializable class.
258 */
259 private static final long serialVersionUID = 2709857663883498069L;
260
261
262
263 // The number of available CPUs.
264 private final Long availableCPUs;
265
266 // The amount of free memory held by the JVM.
267 private final Long freeMemory;
268
269 // The PID of the JVM in which the server is running.
270 private final Long jvmPID;
271
272 // The maximum amount of memory the JVM can use.
273 private final Long maxMemory;
274
275 // The amount of memory currently held by the JVM.
276 private final Long usedMemory;
277
278 // The set of environment variables defined in the server process.
279 private final Map<String,String> environmentVariables;
280
281 // The set of system properties defined in the JVM.
282 private final Map<String,String> systemProperties;
283
284 // The server's classpath.
285 private final String classpath;
286
287 // The server's hostname.
288 private final String hostname;
289
290 // The path to the server instance root.
291 private final String instanceRoot;
292
293 // The server's Java home.
294 private final String javaHome;
295
296 // The server's Java vendor string.
297 private final String javaVendor;
298
299 // The server's Java version string.
300 private final String javaVersion;
301
302 // The server's JVM architecture.
303 private final String jvmArchitecture;
304
305 // The set of arguments provided to the JVM.
306 private final String jvmArguments;
307
308 // The server's JVM vendor string.
309 private final String jvmVendor;
310
311 // The server's JVM version string.
312 private final String jvmVersion;
313
314 // The name of the operating system on which the server is running.
315 private final String operatingSystem;
316
317 // The name of the default SSL context protocol that has been selected by the
318 // server.
319 private final String sslContextProtocol;
320
321 // The name of the user as whom the server is running.
322 private final String userName;
323
324 // The path to the server's current working directory.
325 private final String workingDirectory;
326
327
328
329 /**
330 * Creates a new system info monitor entry from the provided entry.
331 *
332 * @param entry The entry to be parsed as a system info monitor entry. It
333 * must not be {@code null}.
334 */
335 public SystemInfoMonitorEntry(final Entry entry)
336 {
337 super(entry);
338
339 availableCPUs = getLong(ATTR_AVAILABLE_CPUS);
340 classpath = getString(ATTR_CLASSPATH);
341 freeMemory = getLong(ATTR_FREE_MEMORY);
342 hostname = getString(ATTR_HOSTNAME);
343 instanceRoot = getString(ATTR_INSTANCE_ROOT);
344 javaHome = getString(ATTR_JAVA_HOME);
345 javaVendor = getString(ATTR_JAVA_VENDOR);
346 javaVersion = getString(ATTR_JAVA_VERSION);
347 jvmArchitecture = getString(ATTR_JVM_ARCHITECTURE);
348 jvmArguments = getString(ATTR_JVM_ARGUMENTS);
349 jvmPID = getLong(ATTR_JVM_PID);
350 jvmVendor = getString(ATTR_JVM_VENDOR);
351 jvmVersion = getString(ATTR_JVM_VERSION);
352 maxMemory = getLong(ATTR_MAX_MEMORY);
353 operatingSystem = getString(ATTR_OPERATING_SYSTEM);
354 sslContextProtocol = getString(ATTR_SSL_CONTEXT_PROTOCOL);
355 usedMemory = getLong(ATTR_USED_MEMORY);
356 userName = getString(ATTR_USER_NAME);
357 workingDirectory = getString(ATTR_WORKING_DIRECTORY);
358
359 final List<String> envValues = getStrings(ATTR_ENVIRONMENT_VARIABLE);
360 final LinkedHashMap<String,String> envMap =
361 new LinkedHashMap<String,String>(envValues.size());
362 for (final String s : envValues)
363 {
364 final int eqPos = s.indexOf("='");
365 if (eqPos > 0)
366 {
367 final String name = s.substring(0, eqPos);
368 if (eqPos != (s.length() - 2))
369 {
370 envMap.put(name, s.substring(eqPos+2, (s.length() - 1)));
371 }
372 }
373 }
374 environmentVariables = Collections.unmodifiableMap(envMap);
375
376 final List<String> propValues = getStrings(ATTR_SYSTEM_PROPERTY);
377 final LinkedHashMap<String,String> propMap =
378 new LinkedHashMap<String,String>(propValues.size());
379 for (final String s : propValues)
380 {
381 final int eqPos = s.indexOf("='");
382 if (eqPos > 0)
383 {
384 final String name = s.substring(0, eqPos);
385 if (eqPos != (s.length() - 2))
386 {
387 propMap.put(name, s.substring(eqPos+2, (s.length() - 1)));
388 }
389 }
390 }
391 systemProperties = Collections.unmodifiableMap(propMap);
392 }
393
394
395
396 /**
397 * Retrieves the number of CPUs available to the JVM.
398 *
399 * @return The number of CPUs available to the JVM, or {@code null} if it was
400 * not included in the monitor entry.
401 */
402 public Long getAvailableCPUs()
403 {
404 return availableCPUs;
405 }
406
407
408
409 /**
410 * Retrieves the server's Java classpath.
411 *
412 * @return The server's Java classpath, or {@code null} if it was not
413 * included in the monitor entry.
414 */
415 public String getClassPath()
416 {
417 return classpath;
418 }
419
420
421
422 /**
423 * Retrieves the environment variables available to the server process, mapped
424 * from variable name to the corresponding value.
425 *
426 * @return The environment variables available to the server process, or an
427 * empty map if it was not included in the monitor entry.
428 */
429 public Map<String,String> getEnvironmentVariables()
430 {
431 return environmentVariables;
432 }
433
434
435
436 /**
437 * Retrieves the amount of memory in bytes held by the JVM that is currently
438 * marked as free.
439 *
440 * @return The amount of memory in bytes held by the JVM that is currently
441 * marked as free, or {@code null} if it was not included in the
442 * monitor entry.
443 */
444 public Long getFreeMemory()
445 {
446 return freeMemory;
447 }
448
449
450
451 /**
452 * Retrieves the server's hostname.
453 *
454 * @return The server's hostname, or {@code null} if it was not included in
455 * the monitor entry.
456 */
457 public String getHostname()
458 {
459 return hostname;
460 }
461
462
463
464 /**
465 * Retrieves the path to the directory in which the Directory Server is
466 * installed.
467 *
468 * @return The path to the directory in which the Directory Server is
469 * installed, or {@code null} if it was not included in the monitor
470 * entry.
471 */
472 public String getInstanceRoot()
473 {
474 return instanceRoot;
475 }
476
477
478
479 /**
480 * Retrieves the path to the Java installation used by the server.
481 *
482 * @return The path to the Java installation used by the server, or
483 * {@code null} if it was not included in the monitor entry.
484 */
485 public String getJavaHome()
486 {
487 return javaHome;
488 }
489
490
491
492 /**
493 * Retrieves the server's Java vendor string.
494 *
495 * @return The server's Java vendor string, or {@code null} if it was not
496 * included in the monitor entry.
497 */
498 public String getJavaVendor()
499 {
500 return javaVendor;
501 }
502
503
504
505 /**
506 * Retrieves the server's Java version string.
507 *
508 * @return The server's Java version string, or {@code null} if it was not
509 * included in the monitor entry.
510 */
511 public String getJavaVersion()
512 {
513 return javaVersion;
514 }
515
516
517
518 /**
519 * Retrieves the server's JVM architecture data mode, which should indicate
520 * whether the server is running a 32-bit or 64-bit JVM.
521 *
522 * @return The server's JVM architecture data model, or {@code null} if it
523 * was not included in the monitor entry.
524 */
525 public String getJVMArchitectureDataModel()
526 {
527 return jvmArchitecture;
528 }
529
530
531
532 /**
533 * Retrieves a list of the arguments provided to the JVM when the server was
534 * started.
535 *
536 * @return A list of the arguments provided to the JVM when the server was
537 * started, or {@code null} if it was not included in the monitor
538 * entry.
539 */
540 public String getJVMArguments()
541 {
542 return jvmArguments;
543 }
544
545
546
547 /**
548 * Retrieves the process ID of the JVM in which the server is running.
549 *
550 * @return The process ID of the JVM in which the server is running, or
551 * {@code null} if it was not included in the monitor entry.
552 */
553 public Long getJVMPID()
554 {
555 return jvmPID;
556 }
557
558
559
560 /**
561 * Retrieves the server's JVM vendor string.
562 *
563 * @return The server's JVM vendor string, or {@code null} if it was not
564 * included in the monitor entry.
565 */
566 public String getJVMVendor()
567 {
568 return jvmVendor;
569 }
570
571
572
573 /**
574 * Retrieves the server's JVM version string.
575 *
576 * @return The server's JVM version string, or {@code null} if it was not
577 * included in the monitor entry.
578 */
579 public String getJVMVersion()
580 {
581 return jvmVersion;
582 }
583
584
585
586 /**
587 * Retrieves the maximum amount of memory in bytes that the JVM will be
588 * allowed to use.
589 *
590 * @return The maximum amount of memory in bytes that the JVM will be allowed
591 * to use, or {@code null} if it was not included in the monitor
592 * entry.
593 */
594 public Long getMaxMemory()
595 {
596 return maxMemory;
597 }
598
599
600
601 /**
602 * Retrieves information about the operating system on which the server is
603 * running.
604 *
605 * @return Information about the operating system on which the server is
606 * running, or {@code null} if it was not included in the monitor
607 * entry.
608 */
609 public String getOperatingSystem()
610 {
611 return operatingSystem;
612 }
613
614
615
616 /**
617 * Retrieves the name of the default SSL context protocol that has been
618 * selected by the server.
619 *
620 * @return The name of the default SSL context protocol that has been
621 * selected by the server.
622 */
623 public String getSSLContextProtocol()
624 {
625 return sslContextProtocol;
626 }
627
628
629
630 /**
631 * Retrieves the system properties defined in the server JVM, mapped from
632 * property name to the corresponding value.
633 *
634 * @return The system properties defined in the server JVM, or an empty map
635 * if it was not included in the monitor entry.
636 */
637 public Map<String,String> getSystemProperties()
638 {
639 return systemProperties;
640 }
641
642
643
644 /**
645 * Retrieves the amount of memory in bytes currently held by the JVM used to
646 * run the server.
647 *
648 * @return The amount of memory in bytes currently held by the JVM used to
649 * run the server, or {@code null} if it was not included in the
650 * monitor entry
651 */
652 public Long getUsedMemory()
653 {
654 return usedMemory;
655 }
656
657
658
659 /**
660 * Retrieves the name of the user as whom the server is running.
661 *
662 * @return The name of the user as whom the server is running, or
663 * {@code null} if it was not included in the monitor entry.
664 */
665 public String getUserName()
666 {
667 return userName;
668 }
669
670
671
672 /**
673 * Retrieves the path to the server's current working directory. This is
674 * generally the path to the directory from which the server was started.
675 *
676 * @return The path to the server's current working directory, or
677 * {@code null} if it was not included in the monitor entry.
678 */
679 public String getWorkingDirectory()
680 {
681 return workingDirectory;
682 }
683
684
685
686 /**
687 * {@inheritDoc}
688 */
689 @Override()
690 public String getMonitorDisplayName()
691 {
692 return INFO_SYSTEM_INFO_MONITOR_DISPNAME.get();
693 }
694
695
696
697 /**
698 * {@inheritDoc}
699 */
700 @Override()
701 public String getMonitorDescription()
702 {
703 return INFO_SYSTEM_INFO_MONITOR_DESC.get();
704 }
705
706
707
708 /**
709 * {@inheritDoc}
710 */
711 @Override()
712 public Map<String,MonitorAttribute> getMonitorAttributes()
713 {
714 final LinkedHashMap<String,MonitorAttribute> attrs =
715 new LinkedHashMap<String,MonitorAttribute>();
716
717 if (hostname != null)
718 {
719 addMonitorAttribute(attrs,
720 ATTR_HOSTNAME,
721 INFO_SYSTEM_INFO_DISPNAME_HOSTNAME.get(),
722 INFO_SYSTEM_INFO_DESC_HOSTNAME.get(),
723 hostname);
724 }
725
726 if (operatingSystem != null)
727 {
728 addMonitorAttribute(attrs,
729 ATTR_OPERATING_SYSTEM,
730 INFO_SYSTEM_INFO_DISPNAME_OPERATING_SYSTEM.get(),
731 INFO_SYSTEM_INFO_DESC_OPERATING_SYSTEM.get(),
732 operatingSystem);
733 }
734
735 if (jvmArchitecture != null)
736 {
737 addMonitorAttribute(attrs,
738 ATTR_JVM_ARCHITECTURE,
739 INFO_SYSTEM_INFO_DISPNAME_JVM_ARCHITECTURE.get(),
740 INFO_SYSTEM_INFO_DESC_JVM_ARCHITECTURE.get(),
741 jvmArchitecture);
742 }
743
744 if (javaHome != null)
745 {
746 addMonitorAttribute(attrs,
747 ATTR_JAVA_HOME,
748 INFO_SYSTEM_INFO_DISPNAME_JAVA_HOME.get(),
749 INFO_SYSTEM_INFO_DESC_JAVA_HOME.get(),
750 javaHome);
751 }
752
753 if (javaVersion != null)
754 {
755 addMonitorAttribute(attrs,
756 ATTR_JAVA_VERSION,
757 INFO_SYSTEM_INFO_DISPNAME_JAVA_VERSION.get(),
758 INFO_SYSTEM_INFO_DESC_JAVA_VERSION.get(),
759 javaVersion);
760 }
761
762 if (javaVendor != null)
763 {
764 addMonitorAttribute(attrs,
765 ATTR_JAVA_VENDOR,
766 INFO_SYSTEM_INFO_DISPNAME_JAVA_VENDOR.get(),
767 INFO_SYSTEM_INFO_DESC_JAVA_VENDOR.get(),
768 javaVendor);
769 }
770
771 if (jvmVersion != null)
772 {
773 addMonitorAttribute(attrs,
774 ATTR_JVM_VERSION,
775 INFO_SYSTEM_INFO_DISPNAME_JVM_VERSION.get(),
776 INFO_SYSTEM_INFO_DESC_JVM_VERSION.get(),
777 jvmVersion);
778 }
779
780 if (jvmVendor != null)
781 {
782 addMonitorAttribute(attrs,
783 ATTR_JVM_VENDOR,
784 INFO_SYSTEM_INFO_DISPNAME_JVM_VENDOR.get(),
785 INFO_SYSTEM_INFO_DESC_JVM_VENDOR.get(),
786 jvmVendor);
787 }
788
789 if (jvmArguments != null)
790 {
791 addMonitorAttribute(attrs,
792 ATTR_JVM_ARGUMENTS,
793 INFO_SYSTEM_INFO_DISPNAME_JVM_ARGUMENTS.get(),
794 INFO_SYSTEM_INFO_DESC_JVM_ARGUMENTS.get(),
795 jvmArguments);
796 }
797
798 if (jvmPID != null)
799 {
800 addMonitorAttribute(attrs,
801 ATTR_JVM_PID,
802 INFO_SYSTEM_INFO_DISPNAME_JVM_PID.get(),
803 INFO_SYSTEM_INFO_DESC_JVM_PID.get(),
804 jvmPID);
805 }
806
807 if (sslContextProtocol != null)
808 {
809 addMonitorAttribute(attrs,
810 ATTR_SSL_CONTEXT_PROTOCOL,
811 INFO_SYSTEM_INFO_DISPNAME_SSL_CONTEXT_PROTOCOL.get(),
812 INFO_SYSTEM_INFO_DESC_SSL_CONTEXT_PROTOCOL.get(),
813 sslContextProtocol);
814 }
815
816 if (classpath != null)
817 {
818 addMonitorAttribute(attrs,
819 ATTR_CLASSPATH,
820 INFO_SYSTEM_INFO_DISPNAME_CLASSPATH.get(),
821 INFO_SYSTEM_INFO_DESC_CLASSPATH.get(),
822 classpath);
823 }
824
825 if (instanceRoot != null)
826 {
827 addMonitorAttribute(attrs,
828 ATTR_INSTANCE_ROOT,
829 INFO_SYSTEM_INFO_DISPNAME_INSTANCE_ROOT.get(),
830 INFO_SYSTEM_INFO_DESC_INSTANCE_ROOT.get(),
831 instanceRoot);
832 }
833
834 if (workingDirectory != null)
835 {
836 addMonitorAttribute(attrs,
837 ATTR_WORKING_DIRECTORY,
838 INFO_SYSTEM_INFO_DISPNAME_WORKING_DIRECTORY.get(),
839 INFO_SYSTEM_INFO_DESC_WORKING_DIRECTORY.get(),
840 workingDirectory);
841 }
842
843 if (availableCPUs != null)
844 {
845 addMonitorAttribute(attrs,
846 ATTR_AVAILABLE_CPUS,
847 INFO_SYSTEM_INFO_DISPNAME_AVAILABLE_CPUS.get(),
848 INFO_SYSTEM_INFO_DESC_AVAILABLE_CPUS.get(),
849 availableCPUs);
850 }
851
852 if (usedMemory != null)
853 {
854 addMonitorAttribute(attrs,
855 ATTR_USED_MEMORY,
856 INFO_SYSTEM_INFO_DISPNAME_USED_MEMORY.get(),
857 INFO_SYSTEM_INFO_DESC_USED_MEMORY.get(),
858 usedMemory);
859 }
860
861 if (maxMemory != null)
862 {
863 addMonitorAttribute(attrs,
864 ATTR_MAX_MEMORY,
865 INFO_SYSTEM_INFO_DISPNAME_MAX_MEMORY.get(),
866 INFO_SYSTEM_INFO_DESC_MAX_MEMORY.get(),
867 maxMemory);
868 }
869
870 if (freeMemory != null)
871 {
872 addMonitorAttribute(attrs,
873 ATTR_FREE_MEMORY,
874 INFO_SYSTEM_INFO_DISPNAME_FREE_MEMORY.get(),
875 INFO_SYSTEM_INFO_DESC_FREE_MEMORY.get(),
876 freeMemory);
877 }
878
879 if (userName != null)
880 {
881 addMonitorAttribute(attrs,
882 ATTR_USER_NAME,
883 INFO_SYSTEM_INFO_DISPNAME_USER_NAME.get(),
884 INFO_SYSTEM_INFO_DESC_USER_NAME.get(),
885 userName);
886 }
887
888 if (! environmentVariables.isEmpty())
889 {
890 final ArrayList<String> envList =
891 new ArrayList<String>(environmentVariables.size());
892 for (final Map.Entry<String,String> e : environmentVariables.entrySet())
893 {
894 envList.add(e.getKey() + "='" + e.getValue() + '\'');
895 }
896
897 addMonitorAttribute(attrs,
898 ATTR_ENVIRONMENT_VARIABLE,
899 INFO_SYSTEM_INFO_DISPNAME_ENV_VAR.get(),
900 INFO_SYSTEM_INFO_DESC_ENV_VAR.get(),
901 envList);
902 }
903
904 if (! systemProperties.isEmpty())
905 {
906 final ArrayList<String> propList =
907 new ArrayList<String>(systemProperties.size());
908 for (final Map.Entry<String,String> e : systemProperties.entrySet())
909 {
910 propList.add(e.getKey() + "='" + e.getValue() + '\'');
911 }
912
913 addMonitorAttribute(attrs,
914 ATTR_SYSTEM_PROPERTY,
915 INFO_SYSTEM_INFO_DISPNAME_SYSTEM_PROP.get(),
916 INFO_SYSTEM_INFO_DESC_SYSTEM_PROP.get(),
917 propList);
918 }
919
920 return Collections.unmodifiableMap(attrs);
921 }
922 }