001 /* 002 * Copyright 2013-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.controls; 022 023 024 025 import java.io.Serializable; 026 import java.util.ArrayList; 027 028 import com.unboundid.asn1.ASN1Element; 029 import com.unboundid.asn1.ASN1Enumerated; 030 import com.unboundid.asn1.ASN1Integer; 031 import com.unboundid.asn1.ASN1Sequence; 032 import com.unboundid.ldap.sdk.LDAPException; 033 import com.unboundid.ldap.sdk.ResultCode; 034 import com.unboundid.util.Debug; 035 import com.unboundid.util.NotMutable; 036 import com.unboundid.util.StaticUtils; 037 import com.unboundid.util.ThreadSafety; 038 import com.unboundid.util.ThreadSafetyLevel; 039 040 import static com.unboundid.ldap.sdk.unboundidds.controls.ControlMessages.*; 041 042 043 044 /** 045 * <BLOCKQUOTE> 046 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 047 * LDAP SDK for Java. It is not available for use in applications that 048 * include only the Standard Edition of the LDAP SDK, and is not supported for 049 * use in conjunction with non-UnboundID products. 050 * </BLOCKQUOTE> 051 * This class defines a data structure that provides information about the 052 * result of assured replication processing, either on a replication server (if 053 * that is all that is needed to satisfy the desired level of assurance) or 054 * on a directory server (if required by the desired level of assurance). 055 */ 056 @NotMutable() 057 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 058 public final class AssuredReplicationServerResult 059 implements Serializable 060 { 061 /** 062 * The BER type for the result code element. 063 */ 064 private static final byte TYPE_RESULT_CODE = (byte) 0x80; 065 066 067 /** 068 * The BER type for the server ID element. 069 */ 070 private static final byte TYPE_SERVER_ID = (byte) 0x81; 071 072 073 /** 074 * The BER type for the replica ID element. 075 */ 076 private static final byte TYPE_REPLICA_ID = (byte) 0x82; 077 078 079 080 /** 081 * The serial version UID for this serializable class. 082 */ 083 private static final long serialVersionUID = 3015162215769386343L; 084 085 086 087 // The result code for this server result. 088 private final AssuredReplicationServerResultCode resultCode; 089 090 // The replica ID of the associated directory server. 091 private final Short replicaID; 092 093 // The server ID of the associated replication server. 094 private final Short replicationServerID; 095 096 097 098 /** 099 * Creates a new assured replication server result with the provided 100 * information. 101 * 102 * @param resultCode The result code that indicates the state of 103 * assurance processing for the associated 104 * replication server and/or directory server. 105 * It must not be {@code null}. 106 * @param replicationServerID The server ID of the replication server from 107 * which this server result was obtained. It may 108 * be {@code null} if no replication server ID is 109 * available for this result. 110 * @param replicaID The replica ID of the directory server with 111 * which this result is associated. It may be 112 * {@code null} if no replica ID is available 113 * for this result. 114 */ 115 public AssuredReplicationServerResult( 116 final AssuredReplicationServerResultCode resultCode, 117 final Short replicationServerID, 118 final Short replicaID) 119 { 120 this.resultCode = resultCode; 121 this.replicationServerID = replicationServerID; 122 this.replicaID = replicaID; 123 } 124 125 126 127 /** 128 * Retrieves the result code that indicates the state of assurance processing 129 * for this server result. 130 * 131 * @return The result code for this server result. 132 */ 133 public AssuredReplicationServerResultCode getResultCode() 134 { 135 return resultCode; 136 } 137 138 139 140 /** 141 * Retrieves the server ID for the replication server from which this server 142 * result was obtained, if available. 143 * 144 * @return The server ID for the replication server from which this server 145 * result was obtained, or {@code null} if no replication server ID 146 * is available. 147 */ 148 public Short getReplicationServerID() 149 { 150 return replicationServerID; 151 } 152 153 154 155 /** 156 * Retrieves the replica ID for the directory server with which this server 157 * result is associated, if applicable. 158 * 159 * @return The replica ID for the directory server with which this server 160 * result is associated, or {@code null} if there is no associated 161 * directory server. 162 */ 163 public Short getReplicaID() 164 { 165 return replicaID; 166 } 167 168 169 170 /** 171 * Encodes this assured replication server result to an ASN.1 element suitable 172 * for use in a {@link AssuredReplicationResponseControl}. 173 * 174 * @return The encoded representation of this assured replication server 175 * result. 176 */ 177 ASN1Element encode() 178 { 179 final ArrayList<ASN1Element> elements = new ArrayList<ASN1Element>(3); 180 181 elements.add(new ASN1Enumerated(TYPE_RESULT_CODE, resultCode.intValue())); 182 183 if (replicationServerID != null) 184 { 185 elements.add(new ASN1Integer(TYPE_SERVER_ID, replicationServerID)); 186 } 187 188 if (replicaID != null) 189 { 190 elements.add(new ASN1Integer(TYPE_REPLICA_ID, replicaID)); 191 } 192 193 return new ASN1Sequence(elements); 194 } 195 196 197 198 /** 199 * Decodes the provided ASN.1 element as an assured replication server 200 * result. 201 * 202 * @param element The ASN.1 element to be decoded. It must not be 203 * {@code null}. 204 * 205 * @return The decoded assured replication server result. 206 * 207 * @throws LDAPException If a problem is encountered while attempting to 208 * decode the provided ASN.1 element as an assured 209 * replication server result. 210 */ 211 static AssuredReplicationServerResult decode(final ASN1Element element) 212 throws LDAPException 213 { 214 AssuredReplicationServerResultCode resultCode = null; 215 Short serverID = null; 216 Short replicaID = null; 217 218 try 219 { 220 for (final ASN1Element e : 221 ASN1Sequence.decodeAsSequence(element).elements()) 222 { 223 switch (e.getType()) 224 { 225 case TYPE_RESULT_CODE: 226 final int rcValue = ASN1Enumerated.decodeAsEnumerated(e).intValue(); 227 resultCode = AssuredReplicationServerResultCode.valueOf(rcValue); 228 if (resultCode == null) 229 { 230 throw new LDAPException(ResultCode.DECODING_ERROR, 231 ERR_ASSURED_REPLICATION_SERVER_RESULT_INVALID_RESULT_CODE. 232 get(rcValue)); 233 } 234 break; 235 236 case TYPE_SERVER_ID: 237 serverID = (short) ASN1Integer.decodeAsInteger(e).intValue(); 238 break; 239 240 case TYPE_REPLICA_ID: 241 replicaID = (short) ASN1Integer.decodeAsInteger(e).intValue(); 242 break; 243 244 default: 245 throw new LDAPException(ResultCode.DECODING_ERROR, 246 ERR_ASSURED_REPLICATION_SERVER_RESULT_UNEXPECTED_ELEMENT_TYPE. 247 get(StaticUtils.toHex(e.getType()))); 248 } 249 } 250 } 251 catch (final LDAPException le) 252 { 253 Debug.debugException(le); 254 throw le; 255 } 256 catch (final Exception e) 257 { 258 Debug.debugException(e); 259 throw new LDAPException(ResultCode.DECODING_ERROR, 260 ERR_ASSURED_REPLICATION_SERVER_RESULT_CANNOT_DECODE.get( 261 StaticUtils.getExceptionMessage(e)), 262 e); 263 } 264 265 if (resultCode == null) 266 { 267 throw new LDAPException(ResultCode.DECODING_ERROR, 268 ERR_ASSURED_REPLICATION_SERVER_RESULT_NO_RESULT_CODE.get()); 269 } 270 271 return new AssuredReplicationServerResult(resultCode, serverID, replicaID); 272 } 273 274 275 276 /** 277 * Retrieves a string representation of this assured replication server 278 * result. 279 * 280 * @return A string representation of this assured replication server 281 * result. 282 */ 283 @Override() 284 public String toString() 285 { 286 final StringBuilder buffer = new StringBuilder(); 287 toString(buffer); 288 return buffer.toString(); 289 } 290 291 292 293 /** 294 * Appends a string representation of this assured replication server result 295 * to the provided buffer. 296 * 297 * @param buffer The buffer to which the information should be appended. 298 */ 299 public void toString(final StringBuilder buffer) 300 { 301 buffer.append("AssuredReplicationServerResult(resultCode="); 302 buffer.append(resultCode.name()); 303 304 if (replicationServerID != null) 305 { 306 buffer.append(", replicationServerID="); 307 buffer.append(replicationServerID); 308 } 309 310 if (replicaID != null) 311 { 312 buffer.append(", replicaID="); 313 buffer.append(replicaID); 314 } 315 316 buffer.append(')'); 317 } 318 }