001 /* 002 * Copyright 2009-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.DN; 032 import com.unboundid.ldap.sdk.Entry; 033 import com.unboundid.util.NotMutable; 034 import com.unboundid.util.ThreadSafety; 035 import com.unboundid.util.ThreadSafetyLevel; 036 037 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 038 import static com.unboundid.util.Debug.*; 039 040 041 042 /** 043 * <BLOCKQUOTE> 044 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 045 * LDAP SDK for Java. It is not available for use in applications that 046 * include only the Standard Edition of the LDAP SDK, and is not supported for 047 * use in conjunction with non-UnboundID products. 048 * </BLOCKQUOTE> 049 * This class defines a monitor entry that provides information about the state 050 * of a replication server, including the base DNs for replicated content, the 051 * generation ID for each of those base DNs, the replication server ID, and the 052 * port number on which the replication server is listening. 053 * <BR><BR> 054 * The server should present at most one replication server monitor entry. It 055 * can be retrieved using the 056 * {@link MonitorManager#getReplicationServerMonitorEntry} method. This entry 057 * provides specific methods for accessing information about the replication 058 * server. Alternately, this information may be accessed using the generic API. 059 * See the {@link MonitorManager} class documentation for an example that 060 * demonstrates the use of the generic API for accessing monitor data. 061 */ 062 @NotMutable() 063 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 064 public final class ReplicationServerMonitorEntry 065 extends MonitorEntry 066 { 067 /** 068 * The structural object class used in replication server monitor entries. 069 */ 070 static final String REPLICATION_SERVER_MONITOR_OC = 071 "ds-replication-server-monitor-entry"; 072 073 074 075 /** 076 * The name of the attribute that contains the base DNs for the replicated 077 * data. 078 */ 079 private static final String ATTR_BASE_DN = "base-dn"; 080 081 082 083 /** 084 * The name of the attribute that contains the generation IDs that correspond 085 * to the replicated base DNs. 086 */ 087 private static final String ATTR_BASE_DN_GENERATION_ID = 088 "base-dn-generation-id"; 089 090 091 092 /** 093 * The name of the attribute that contains the server ID for the replication 094 * server. 095 */ 096 private static final String ATTR_REPLICATION_SERVER_ID = 097 "replication-server-id"; 098 099 100 101 /** 102 * The name of the attribute that contains the port number on which the 103 * replication server listens for communication from other servers. 104 */ 105 private static final String ATTR_REPLICATION_SERVER_PORT = 106 "replication-server-port"; 107 108 109 110 /** 111 * The name of the attribute that indicates whether SSL encryption is 112 * available for use. 113 */ 114 private static final String ATTR_SSL_AVAILABLE = 115 "ssl-encryption-available"; 116 117 118 119 /** 120 * The serial version UID for this serializable class. 121 */ 122 private static final long serialVersionUID = 7488640967498574690L; 123 124 125 126 // Indicates whether SSL encryption is available. 127 private final Boolean sslEncryptionAvailable; 128 129 // The base DNs for the replicated data. 130 private final List<String> baseDNs; 131 132 // The port number on which the replication server listens for communication 133 // from other servers. 134 private final Long replicationServerPort; 135 136 // A map of the generation IDs for each of the replicated base DNs. 137 private final Map<DN,String> generationIDs; 138 139 // The replication server ID for the replication server. 140 private final String replicationServerID; 141 142 143 144 /** 145 * Creates a new replication server monitor entry from the provided entry. 146 * 147 * @param entry The entry to be parsed as a replication server monitor 148 * entry. It must not be {@code null}. 149 */ 150 public ReplicationServerMonitorEntry(final Entry entry) 151 { 152 super(entry); 153 154 baseDNs = getStrings(ATTR_BASE_DN); 155 replicationServerID = getString(ATTR_REPLICATION_SERVER_ID); 156 replicationServerPort = getLong(ATTR_REPLICATION_SERVER_PORT); 157 sslEncryptionAvailable = getBoolean(ATTR_SSL_AVAILABLE); 158 159 final List<String> baseDNsAndIDs = getStrings(ATTR_BASE_DN_GENERATION_ID); 160 final Map<DN,String> idMap = 161 new LinkedHashMap<DN,String>(baseDNsAndIDs.size()); 162 for (final String s : baseDNsAndIDs) 163 { 164 try 165 { 166 final int lastSpacePos = s.lastIndexOf(' '); 167 final DN dn = new DN(s.substring(0, lastSpacePos)); 168 idMap.put(dn, s.substring(lastSpacePos+1)); 169 } 170 catch (Exception e) 171 { 172 debugException(e); 173 } 174 } 175 generationIDs = Collections.unmodifiableMap(idMap); 176 } 177 178 179 180 /** 181 * Retrieves the base DNs for replicated content managed by this replication 182 * server. 183 * 184 * @return The base DNs for replicated content managed by this replication 185 * server, or an empty list if it was not included in the monitor 186 * entry. 187 */ 188 public List<String> getBaseDNs() 189 { 190 return baseDNs; 191 } 192 193 194 195 /** 196 * Retrieves a map of generation IDs for the available base DNs. 197 * 198 * @return A map of generation IDs for the available base DNs, or an empty 199 * map if it was not included in the monitor entry. 200 */ 201 public Map<DN,String> getGenerationIDs() 202 { 203 return generationIDs; 204 } 205 206 207 208 /** 209 * Retrieves the generation ID for the specified base DN. 210 * 211 * @param baseDN The base DN for which to retrieve the generation ID. 212 * 213 * @return The generation ID for the specified base DN, or {@code null} if 214 * there no generation ID is available for the provided base DN, or 215 * the provided base DN is not a valid DN. 216 */ 217 public String getGenerationID(final String baseDN) 218 { 219 try 220 { 221 return getGenerationID(new DN(baseDN)); 222 } 223 catch (Exception e) 224 { 225 debugException(e); 226 return null; 227 } 228 } 229 230 231 232 /** 233 * Retrieves the generation ID for the specified base DN. 234 * 235 * @param baseDN The base DN for which to retrieve the generation ID. 236 * 237 * @return The generation ID for the specified base DN, or {@code null} if 238 * there no generation ID is available for the provided base DN. 239 */ 240 public String getGenerationID(final DN baseDN) 241 { 242 return generationIDs.get(baseDN); 243 } 244 245 246 247 /** 248 * Retrieves the server ID for the replication server. 249 * 250 * @return The server ID for the replication server, or {@code null} if it 251 * was not included in the monitor entry. 252 */ 253 public String getReplicationServerID() 254 { 255 return replicationServerID; 256 } 257 258 259 260 /** 261 * Retrieves the port number for the replication server. 262 * 263 * @return The port number for the replication server, or {@code null} if it 264 * was not included in the monitor entry. 265 */ 266 public Long getReplicationServerPort() 267 { 268 return replicationServerPort; 269 } 270 271 272 273 /** 274 * Indicates whether the replication server provides support for SSL 275 * encryption. 276 * 277 * @return {@code true} if the replication server supports SSL encryption, 278 * {@code false} if it does not, or {@code null} if that information 279 * was not included in the monitor entry. 280 */ 281 public Boolean sslEncryptionAvailable() 282 { 283 return sslEncryptionAvailable; 284 } 285 286 287 288 /** 289 * {@inheritDoc} 290 */ 291 @Override() 292 public String getMonitorDisplayName() 293 { 294 return INFO_REPLICATION_SERVER_MONITOR_DISPNAME.get(); 295 } 296 297 298 299 /** 300 * {@inheritDoc} 301 */ 302 @Override() 303 public String getMonitorDescription() 304 { 305 return INFO_REPLICATION_SERVER_MONITOR_DESC.get(); 306 } 307 308 309 310 /** 311 * {@inheritDoc} 312 */ 313 @Override() 314 public Map<String,MonitorAttribute> getMonitorAttributes() 315 { 316 final LinkedHashMap<String,MonitorAttribute> attrs = 317 new LinkedHashMap<String,MonitorAttribute>(); 318 319 if (! baseDNs.isEmpty()) 320 { 321 addMonitorAttribute(attrs, 322 ATTR_BASE_DN, 323 INFO_REPLICATION_SERVER_DISPNAME_BASE_DN.get(), 324 INFO_REPLICATION_SERVER_DESC_BASE_DN.get(), 325 baseDNs); 326 } 327 328 if (! generationIDs.isEmpty()) 329 { 330 final ArrayList<String> idStrings = 331 new ArrayList<String>(generationIDs.size()); 332 for (final Map.Entry<DN,String> e : generationIDs.entrySet()) 333 { 334 idStrings.add(e.getKey().toNormalizedString() + ' ' + e.getValue()); 335 } 336 337 addMonitorAttribute(attrs, 338 ATTR_BASE_DN_GENERATION_ID, 339 INFO_REPLICATION_SERVER_DISPNAME_BASE_DN_GENERATION_ID.get(), 340 INFO_REPLICATION_SERVER_DESC_BASE_DN_GENERATION_ID.get(), 341 idStrings); 342 } 343 344 if (replicationServerID != null) 345 { 346 addMonitorAttribute(attrs, 347 ATTR_REPLICATION_SERVER_ID, 348 INFO_REPLICATION_SERVER_DISPNAME_REPLICATION_SERVER_ID.get(), 349 INFO_REPLICATION_SERVER_DESC_REPLICATION_SERVER_ID.get(), 350 replicationServerID); 351 } 352 353 if (replicationServerPort != null) 354 { 355 addMonitorAttribute(attrs, 356 ATTR_REPLICATION_SERVER_PORT, 357 INFO_REPLICATION_SERVER_DISPNAME_REPLICATION_SERVER_PORT.get(), 358 INFO_REPLICATION_SERVER_DESC_REPLICATION_SERVER_PORT.get(), 359 replicationServerPort); 360 } 361 362 if (sslEncryptionAvailable != null) 363 { 364 addMonitorAttribute(attrs, 365 ATTR_SSL_AVAILABLE, 366 INFO_REPLICATION_SERVER_DISPNAME_SSL_AVAILABLE.get(), 367 INFO_REPLICATION_SERVER_DESC_SSL_AVAILABLE.get(), 368 sslEncryptionAvailable); 369 } 370 371 return Collections.unmodifiableMap(attrs); 372 } 373 }