001 /* 002 * Copyright 2012-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; 022 023 024 025 import java.io.Serializable; 026 027 import com.unboundid.ldap.sdk.ResultCode; 028 import com.unboundid.util.NotMutable; 029 import com.unboundid.util.ThreadSafety; 030 import com.unboundid.util.ThreadSafetyLevel; 031 032 033 034 /** 035 * <BLOCKQUOTE> 036 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 037 * LDAP SDK for Java. It is not available for use in applications that 038 * include only the Standard Edition of the LDAP SDK, and is not supported for 039 * use in conjunction with non-UnboundID products. 040 * </BLOCKQUOTE> 041 * This class provides a data structure that holds information about the result 042 * of a move subtree operation. 043 */ 044 @NotMutable() 045 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 046 public final class MoveSubtreeResult 047 implements Serializable 048 { 049 /** 050 * The serial version UID for this serializable class. 051 */ 052 private static final long serialVersionUID = 2881207705643180021L; 053 054 055 056 // Indicates whether any changes were made to the data in the source server. 057 private final boolean sourceServerAltered; 058 059 // Indicates whether any changes were made to the data in the target server. 060 private final boolean targetServerAltered; 061 062 // The number of entries added to the target server. 063 private final int entriesAddedToTarget; 064 065 // The number of entries deleted from the source server. 066 private final int entriesDeletedFromSource; 067 068 // The number of entries read from the source server. 069 private final int entriesReadFromSource; 070 071 // The result code resulting from processing. 072 private final ResultCode resultCode; 073 074 // A string providing details of any administrative processing that may be 075 // required to either complete the move or restore servers to their original 076 // state. 077 private final String adminActionRequired; 078 079 // A message with information about any error that may have occurred. 080 private final String errorMessage; 081 082 083 084 /** 085 * Creates a new move subtree result object with the provided information. 086 * 087 * @param resultCode A result code indicating the ultimate 088 * state of the move subtree processing. 089 * @param errorMessage A message with information about any 090 * error that occurred. 091 * @param adminActionRequired A message with information about any 092 * administrative action that may be 093 * required to bring the servers back to a 094 * consistent state. 095 * @param sourceServerAltered Indicates whether any changes were made 096 * to data in the source server. 097 * @param targetServerAltered Indicates whether any changes were made 098 * to data in the target server. 099 * @param entriesReadFromSource The number of entries that were read from 100 * the source server. 101 * @param entriesAddedToTarget The number of entries that were 102 * successfully added to the target server. 103 * @param entriesDeletedFromSource The number of entries that were 104 * successfully removed from the source 105 * server. 106 */ 107 MoveSubtreeResult(final ResultCode resultCode, final String errorMessage, 108 final String adminActionRequired, 109 final boolean sourceServerAltered, 110 final boolean targetServerAltered, 111 final int entriesReadFromSource, 112 final int entriesAddedToTarget, 113 final int entriesDeletedFromSource) 114 { 115 this.resultCode = resultCode; 116 this.errorMessage = errorMessage; 117 this.adminActionRequired = adminActionRequired; 118 this.sourceServerAltered = sourceServerAltered; 119 this.targetServerAltered = targetServerAltered; 120 this.entriesReadFromSource = entriesReadFromSource; 121 this.entriesAddedToTarget = entriesAddedToTarget; 122 this.entriesDeletedFromSource = entriesDeletedFromSource; 123 } 124 125 126 127 /** 128 * Retrieves a result code which indicates the ultimate state of the move 129 * subtree processing. A result of {@code SUCCESS} indicates that all 130 * processing was successful and the subtree was moved from one server to 131 * another. Any other result indicates that some kind of error occurred. 132 * 133 * @return A result code which indicates the ultimate state of the move 134 * subtree processing. 135 */ 136 public ResultCode getResultCode() 137 { 138 return resultCode; 139 } 140 141 142 143 /** 144 * Retrieves an error message with information about a problem that occurred 145 * during processing, if any. 146 * 147 * @return An error message with information about a problem that occurred 148 * during processing, or {@code null} if no errors were encountered. 149 */ 150 public String getErrorMessage() 151 { 152 return errorMessage; 153 } 154 155 156 157 /** 158 * Retrieves a message with information about any administrative action which 159 * may be required to bring data in the servers back into a consistent state 160 * so that the entries in the target subtree will only exist in one of the 161 * two servers. 162 * 163 * @return A message with information about any administrative action which 164 * may be required to bring the data in the servers back into a 165 * consistent state, or {@code null} if no administrative action is 166 * necessary. 167 */ 168 public String getAdminActionRequired() 169 { 170 return adminActionRequired; 171 } 172 173 174 175 /** 176 * Indicates whether any data in the source server has been altered as a 177 * result of the processing performed during the subtree move. A successful 178 * subtree move will cause entries to be removed from the source server, but 179 * there may be error conditions which also result in source server changes. 180 * 181 * @return {@code true} if any data in the source server has been altered as 182 * a result of the processing performed, or {@code false} if not. 183 */ 184 public boolean sourceServerAltered() 185 { 186 return sourceServerAltered; 187 } 188 189 190 191 /** 192 * Indicates whether any data in the target server has been altered as a 193 * result of the processing performed during the subtree move. A successful 194 * subtree move will cause entries to be added to the target server, but 195 * there may be error conditions which also result in target server changes. 196 * 197 * @return {@code true} if any data in the target server has been altered as 198 * a result of the processing performed, or {@code false} if not. 199 */ 200 public boolean targetServerAltered() 201 { 202 return targetServerAltered; 203 } 204 205 206 207 /** 208 * Retrieves the number of entries within the specified subtree read from the 209 * source server. 210 * 211 * @return The number of entries within the specified subtree read from the 212 * source server. 213 */ 214 public int getEntriesReadFromSource() 215 { 216 return entriesReadFromSource; 217 } 218 219 220 221 /** 222 * Retrieves the number of entries added to the target server as a result of 223 * the subtree move. Note that even in a completely successful subtree move, 224 * it is possible for this number to be less than the number of entries read 225 * from the source server if a {@link MoveSubtreeListener} is in use and its 226 * {@code doPreAddProcessing} method returns null for one or more entries to 227 * indicate that those entries should not be added to the target. 228 * 229 * @return The number of entries added to the target server as a result of 230 * the subtree move. 231 */ 232 public int getEntriesAddedToTarget() 233 { 234 return entriesAddedToTarget; 235 } 236 237 238 239 /** 240 * Retrieves the number of entries deleted from the source server as a result 241 * of the subtree move. If all processing is successful, then this value 242 * should match the number of entries read from the source server. 243 * 244 * @return The number of entries deleted from the target server as a result 245 * of the subtree move. 246 */ 247 public int getEntriesDeletedFromSource() 248 { 249 return entriesDeletedFromSource; 250 } 251 252 253 254 /** 255 * Retrieves a string representation of this move subtree result object. 256 * 257 * @return A string representation of this move subtree result object. 258 */ 259 @Override() 260 public String toString() 261 { 262 final StringBuilder buffer = new StringBuilder(); 263 toString(buffer); 264 return buffer.toString(); 265 } 266 267 268 269 /** 270 * Appends a string representation of this move subtree result object to the 271 * provided buffer. 272 * 273 * @param buffer The buffer to which the information should be appended. 274 */ 275 public void toString(final StringBuilder buffer) 276 { 277 buffer.append("MoveSubtreeResult(resultCode="); 278 buffer.append(resultCode.getName()); 279 280 if (errorMessage != null) 281 { 282 buffer.append(", errorMessage='"); 283 buffer.append(errorMessage); 284 buffer.append('\''); 285 } 286 287 if (adminActionRequired != null) 288 { 289 buffer.append(", adminActionRequired='"); 290 buffer.append(adminActionRequired); 291 buffer.append('\''); 292 } 293 294 buffer.append(", sourceServerAltered="); 295 buffer.append(sourceServerAltered); 296 buffer.append(", targetServerAltered="); 297 buffer.append(targetServerAltered); 298 buffer.append(", entriesReadFromSource="); 299 buffer.append(entriesReadFromSource); 300 buffer.append(", entriesAddedToTarget="); 301 buffer.append(entriesAddedToTarget); 302 buffer.append(", entriesDeletedFromSource="); 303 buffer.append(entriesDeletedFromSource); 304 buffer.append(')'); 305 } 306 }