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.tasks; 022 023 024 025 import java.util.ArrayList; 026 import java.util.Arrays; 027 import java.util.Collections; 028 import java.util.Date; 029 import java.util.LinkedHashMap; 030 import java.util.List; 031 import java.util.Map; 032 033 import com.unboundid.ldap.sdk.Attribute; 034 import com.unboundid.ldap.sdk.Entry; 035 import com.unboundid.util.NotMutable; 036 import com.unboundid.util.ThreadSafety; 037 import com.unboundid.util.ThreadSafetyLevel; 038 039 import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*; 040 041 042 043 /** 044 * <BLOCKQUOTE> 045 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 046 * LDAP SDK for Java. It is not available for use in applications that 047 * include only the Standard Edition of the LDAP SDK, and is not supported for 048 * use in conjunction with non-UnboundID products. 049 * </BLOCKQUOTE> 050 * This class defines a Directory Server task that can be used to cause the 051 * server to leave lockdown mode and resume normal operation. Note that because 052 * of the nature of lockdown mode, it this task may only be requested by a user 053 * with the lockdown-mode privilege. Alternately, the server may be restarted 054 * and it will not be placed in lockdown mode at startup unless a significant 055 * problem is encountered in which there may be a risk of unauthorized access to 056 * data. 057 * <BR><BR> 058 * The leave lockdown mode task does not have any task-specific properties. See 059 * the {@link EnterLockdownModeTask} class for more information about lockdown 060 * mode and a task that may be used to force the server to enter this state. 061 */ 062 @NotMutable() 063 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 064 public final class LeaveLockdownModeTask 065 extends Task 066 { 067 /** 068 * The fully-qualified name of the Java class that is used for the leave 069 * lockdown mode task. 070 */ 071 static final String LEAVE_LOCKDOWN_MODE_TASK_CLASS = 072 "com.unboundid.directory.server.tasks.LeaveLockdownModeTask"; 073 074 075 076 /** 077 * The name of the attribute used to specify the reason for taking the server 078 * out of lockdown mode. 079 */ 080 private static final String ATTR_LEAVE_LOCKDOWN_REASON = 081 "ds-task-leave-lockdown-reason"; 082 083 084 085 /** 086 * The task property for the leave-lockdown reason. 087 */ 088 private static final TaskProperty PROPERTY_LEAVE_LOCKDOWN_REASON = 089 new TaskProperty(ATTR_LEAVE_LOCKDOWN_REASON, 090 INFO_DISPLAY_NAME_LEAVE_LOCKDOWN_REASON.get(), 091 INFO_DESCRIPTION_LEAVE_LOCKDOWN_REASON.get(), 092 String.class, false, false, false); 093 094 095 096 /** 097 * The name of the object class used in leave-lockdown-mode task entries. 098 */ 099 private static final String OC_LEAVE_LOCKDOWN_MODE_TASK = 100 "ds-task-leave-lockdown-mode"; 101 102 103 104 /** 105 * The serial version UID for this serializable class. 106 */ 107 private static final long serialVersionUID = -1353712468653879793L; 108 109 110 111 // The reason for leaving lockdown mode. 112 private final String reason; 113 114 115 116 /** 117 * Creates a new uninitialized enter lockdown mode task instance which should 118 * only be used for obtaining general information about this task, including 119 * the task name, description, and supported properties. Attempts to use a 120 * task created with this constructor for any other reason will likely fail. 121 */ 122 public LeaveLockdownModeTask() 123 { 124 reason = null; 125 } 126 127 128 129 /** 130 * Creates a new leave lockdown mode task with the specified task ID. 131 * 132 * @param taskID The task ID to use for this task. If it is {@code null} 133 * then a UUID will be generated for use as the task ID. 134 */ 135 public LeaveLockdownModeTask(final String taskID) 136 { 137 this(taskID, null); 138 } 139 140 141 142 /** 143 * Creates a new leave lockdown mode task with the specified task ID. 144 * 145 * @param taskID The task ID to use for this task. If it is {@code null} 146 * then a UUID will be generated for use as the task ID. 147 * @param reason The user-specified reason for leaving lockdown mode. This 148 * may be {@code null}. 149 */ 150 public LeaveLockdownModeTask(final String taskID, final String reason) 151 { 152 this(taskID, reason, null, null, null, null, null); 153 } 154 155 156 157 /** 158 * Creates a new leave lockdown mode task with the provided information. 159 * 160 * @param taskID The task ID to use for this task. If it is 161 * {@code null} then a UUID will be generated 162 * for use as the task ID. 163 * @param scheduledStartTime The time that this task should start 164 * running. 165 * @param dependencyIDs The list of task IDs that will be required 166 * to complete before this task will be 167 * eligible to start. 168 * @param failedDependencyAction Indicates what action should be taken if 169 * any of the dependencies for this task do 170 * not complete successfully. 171 * @param notifyOnCompletion The list of e-mail addresses of individuals 172 * that should be notified when this task 173 * completes. 174 * @param notifyOnError The list of e-mail addresses of individuals 175 * that should be notified if this task does 176 * not complete successfully. 177 */ 178 public LeaveLockdownModeTask(final String taskID, 179 final Date scheduledStartTime, final List<String> dependencyIDs, 180 final FailedDependencyAction failedDependencyAction, 181 final List<String> notifyOnCompletion, 182 final List<String> notifyOnError) 183 { 184 this(taskID, null, scheduledStartTime, dependencyIDs, 185 failedDependencyAction, notifyOnCompletion, notifyOnError); 186 } 187 188 189 190 /** 191 * Creates a new leave lockdown mode task with the provided information. 192 * 193 * @param taskID The task ID to use for this task. If it is 194 * {@code null} then a UUID will be generated 195 * for use as the task ID. 196 * @param reason The user-specified reason for leaving 197 * lockdown mode. This may be {@code null}. 198 * @param scheduledStartTime The time that this task should start 199 * running. 200 * @param dependencyIDs The list of task IDs that will be required 201 * to complete before this task will be 202 * eligible to start. 203 * @param failedDependencyAction Indicates what action should be taken if 204 * any of the dependencies for this task do 205 * not complete successfully. 206 * @param notifyOnCompletion The list of e-mail addresses of individuals 207 * that should be notified when this task 208 * completes. 209 * @param notifyOnError The list of e-mail addresses of individuals 210 * that should be notified if this task does 211 * not complete successfully. 212 */ 213 public LeaveLockdownModeTask(final String taskID, final String reason, 214 final Date scheduledStartTime, final List<String> dependencyIDs, 215 final FailedDependencyAction failedDependencyAction, 216 final List<String> notifyOnCompletion, 217 final List<String> notifyOnError) 218 { 219 super(taskID, LEAVE_LOCKDOWN_MODE_TASK_CLASS, scheduledStartTime, 220 dependencyIDs, failedDependencyAction, notifyOnCompletion, 221 notifyOnError); 222 223 this.reason = reason; 224 } 225 226 227 228 /** 229 * Creates a new leave lockdown mode task from the provided entry. 230 * 231 * @param entry The entry to use to create this leave lockdown mode task. 232 * 233 * @throws TaskException If the provided entry cannot be parsed as a leave 234 * lockdown mode task entry. 235 */ 236 public LeaveLockdownModeTask(final Entry entry) 237 throws TaskException 238 { 239 super(entry); 240 241 // Get the "reason" string if it is present. 242 reason = entry.getAttributeValue(ATTR_LEAVE_LOCKDOWN_REASON); 243 } 244 245 246 247 /** 248 * Creates a new leave lockdown mode task from the provided set of task 249 * properties. 250 * 251 * @param properties The set of task properties and their corresponding 252 * values to use for the task. It must not be 253 * {@code null}. 254 * 255 * @throws TaskException If the provided set of properties cannot be used to 256 * create a valid leave lockdown mode task. 257 */ 258 public LeaveLockdownModeTask(final Map<TaskProperty,List<Object>> properties) 259 throws TaskException 260 { 261 super(LEAVE_LOCKDOWN_MODE_TASK_CLASS, properties); 262 263 String r = null; 264 for (final Map.Entry<TaskProperty,List<Object>> entry : 265 properties.entrySet()) 266 { 267 final TaskProperty p = entry.getKey(); 268 final String attrName = p.getAttributeName(); 269 final List<Object> values = entry.getValue(); 270 271 if (attrName.equalsIgnoreCase(ATTR_LEAVE_LOCKDOWN_REASON)) 272 { 273 r = parseString(p, values, null); 274 break; 275 } 276 } 277 278 reason = r; 279 } 280 281 282 283 /** 284 * Retrieves the user-specified reason why the server is leaving lockdown 285 * mode. 286 * 287 * @return The reason the server is leaving lockdown mode, or {@code null} 288 * if none was specified. 289 */ 290 public String getReason() 291 { 292 return reason; 293 } 294 295 296 297 /** 298 * {@inheritDoc} 299 */ 300 @Override() 301 public String getTaskName() 302 { 303 return INFO_TASK_NAME_LEAVE_LOCKDOWN_MODE.get(); 304 } 305 306 307 308 /** 309 * {@inheritDoc} 310 */ 311 @Override() 312 public String getTaskDescription() 313 { 314 return INFO_TASK_DESCRIPTION_LEAVE_LOCKDOWN_MODE.get(); 315 } 316 317 318 319 /** 320 * {@inheritDoc} 321 */ 322 @Override() 323 protected List<String> getAdditionalObjectClasses() 324 { 325 return Arrays.asList(OC_LEAVE_LOCKDOWN_MODE_TASK); 326 } 327 328 329 330 /** 331 * {@inheritDoc} 332 */ 333 @Override() 334 protected List<Attribute> getAdditionalAttributes() 335 { 336 final ArrayList<Attribute> attrs = new ArrayList<Attribute>(1); 337 if(reason != null) 338 { 339 attrs.add(new Attribute(ATTR_LEAVE_LOCKDOWN_REASON, reason)); 340 } 341 return attrs; 342 } 343 344 345 346 /** 347 * {@inheritDoc} 348 */ 349 @Override() 350 public List<TaskProperty> getTaskSpecificProperties() 351 { 352 final List<TaskProperty> propList = 353 Arrays.asList(PROPERTY_LEAVE_LOCKDOWN_REASON); 354 355 return Collections.unmodifiableList(propList); 356 } 357 358 359 360 /** 361 * {@inheritDoc} 362 */ 363 @Override() 364 public Map<TaskProperty,List<Object>> getTaskPropertyValues() 365 { 366 final LinkedHashMap<TaskProperty,List<Object>> props = 367 new LinkedHashMap<TaskProperty,List<Object>>(); 368 369 if(reason != null) 370 { 371 props.put(PROPERTY_LEAVE_LOCKDOWN_REASON, 372 Collections.<Object>unmodifiableList(Arrays.asList(reason))); 373 } 374 375 props.putAll(super.getTaskPropertyValues()); 376 return Collections.unmodifiableMap(props); 377 } 378 }