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.Arrays; 026 import java.util.ArrayList; 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 shut down or 051 * restart the server. The properties that are available for use with this type 052 * of task include: 053 * <UL> 054 * <LI>A flag that indicates whether to shut down the server or to perform 055 * an in-core restart (in which the server shuts down and restarts itself 056 * within the same JVM).</LI> 057 * <LI>An optional message that can be used to provide a reason for the 058 * shutdown or restart.</LI> 059 * </UL> 060 */ 061 @NotMutable() 062 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 063 public final class ShutdownTask 064 extends Task 065 { 066 /** 067 * The fully-qualified name of the Java class that is used for the shutdown 068 * task. 069 */ 070 static final String SHUTDOWN_TASK_CLASS = 071 "com.unboundid.directory.server.tasks.ShutdownTask"; 072 073 074 075 /** 076 * The name of the attribute used to define a shutdown message. 077 */ 078 private static final String ATTR_SHUTDOWN_MESSAGE = 079 "ds-task-shutdown-message"; 080 081 082 083 /** 084 * The name of the attribute used to indicate whether to restart rather than 085 * shut down the server. 086 */ 087 private static final String ATTR_RESTART_SERVER = 088 "ds-task-restart-server"; 089 090 091 092 /** 093 * The name of the object class used in shutdown task entries. 094 */ 095 private static final String OC_SHUTDOWN_TASK = "ds-task-shutdown"; 096 097 098 099 /** 100 * The task property for the shutdown message. 101 */ 102 private static final TaskProperty PROPERTY_SHUTDOWN_MESSAGE = 103 new TaskProperty(ATTR_SHUTDOWN_MESSAGE, 104 INFO_DISPLAY_NAME_SHUTDOWN_MESSAGE.get(), 105 INFO_DESCRIPTION_SHUTDOWN_MESSAGE.get(), String.class, 106 false, false, false); 107 108 109 110 /** 111 * The task property for the restart server flag. 112 */ 113 private static final TaskProperty PROPERTY_RESTART_SERVER = 114 new TaskProperty(ATTR_RESTART_SERVER, 115 INFO_DISPLAY_NAME_RESTART_SERVER.get(), 116 INFO_DESCRIPTION_RESTART_SERVER.get(), Boolean.class, 117 false, false, false); 118 119 120 121 /** 122 * The serial version UID for this serializable class. 123 */ 124 private static final long serialVersionUID = -5332685779844073667L; 125 126 127 128 // Indicates whether to restart the server rather than shut it down. 129 private final boolean restartServer; 130 131 // A message that describes the reason for the shutdown. 132 private final String shutdownMessage; 133 134 135 136 /** 137 * Creates a new uninitialized shutdown task instance which should only be 138 * used for obtaining general information about this task, including the task 139 * name, description, and supported properties. Attempts to use a task 140 * created with this constructor for any other reason will likely fail. 141 */ 142 public ShutdownTask() 143 { 144 shutdownMessage = null; 145 restartServer = false; 146 } 147 148 149 150 /** 151 * Creates a new shutdown task with the provided information. 152 * 153 * @param taskID The task ID to use for this task. If it is 154 * {@code null} then a UUID will be generated for use 155 * as the task ID. 156 * @param shutdownMessage A message that describes the reason for the 157 * shutdown. It may be {@code null}. 158 * @param restartServer Indicates whether to restart the server rather 159 * than shut it down. 160 */ 161 public ShutdownTask(final String taskID, final String shutdownMessage, 162 final boolean restartServer) 163 { 164 this(taskID, shutdownMessage, restartServer, null, null, null, null, null); 165 } 166 167 168 169 /** 170 * Creates a new shutdown task with the provided information. 171 * 172 * @param taskID The task ID to use for this task. If it is 173 * {@code null} then a UUID will be generated 174 * for use as the task ID. 175 * @param shutdownMessage A message that describes the reason for the 176 * shutdown. It may be {@code null}. 177 * @param restartServer Indicates whether to restart the server 178 * rather than shut it down. 179 * @param scheduledStartTime The time that this task should start 180 * running. 181 * @param dependencyIDs The list of task IDs that will be required 182 * to complete before this task will be 183 * eligible to start. 184 * @param failedDependencyAction Indicates what action should be taken if 185 * any of the dependencies for this task do 186 * not complete successfully. 187 * @param notifyOnCompletion The list of e-mail addresses of individuals 188 * that should be notified when this task 189 * completes. 190 * @param notifyOnError The list of e-mail addresses of individuals 191 * that should be notified if this task does 192 * not complete successfully. 193 */ 194 public ShutdownTask(final String taskID, final String shutdownMessage, 195 final boolean restartServer, 196 final Date scheduledStartTime, 197 final List<String> dependencyIDs, 198 final FailedDependencyAction failedDependencyAction, 199 final List<String> notifyOnCompletion, 200 final List<String> notifyOnError) 201 { 202 super(taskID, SHUTDOWN_TASK_CLASS, scheduledStartTime, dependencyIDs, 203 failedDependencyAction, notifyOnCompletion, notifyOnError); 204 205 this.shutdownMessage = shutdownMessage; 206 this.restartServer = restartServer; 207 } 208 209 210 211 /** 212 * Creates a new shutdown task from the provided entry. 213 * 214 * @param entry The entry to use to create this shutdown task. 215 * 216 * @throws TaskException If the provided entry cannot be parsed as a 217 * shutdown task entry. 218 */ 219 public ShutdownTask(final Entry entry) 220 throws TaskException 221 { 222 super(entry); 223 224 // Get the shutdown message. It may be absent. 225 shutdownMessage = entry.getAttributeValue(ATTR_SHUTDOWN_MESSAGE); 226 227 228 // Get the restart server flag. It may be absent. 229 restartServer = parseBooleanValue(entry, ATTR_RESTART_SERVER, false); 230 } 231 232 233 234 /** 235 * Creates a new shutdown task from the provided set of task properties. 236 * 237 * @param properties The set of task properties and their corresponding 238 * values to use for the task. It must not be 239 * {@code null}. 240 * 241 * @throws TaskException If the provided set of properties cannot be used to 242 * create a valid shutdown task. 243 */ 244 public ShutdownTask(final Map<TaskProperty,List<Object>> properties) 245 throws TaskException 246 { 247 super(SHUTDOWN_TASK_CLASS, properties); 248 249 boolean r = false; 250 String m = null; 251 252 for (final Map.Entry<TaskProperty,List<Object>> entry : 253 properties.entrySet()) 254 { 255 final TaskProperty p = entry.getKey(); 256 final String attrName = p.getAttributeName(); 257 final List<Object> values = entry.getValue(); 258 259 if (attrName.equalsIgnoreCase(ATTR_SHUTDOWN_MESSAGE)) 260 { 261 m = parseString(p, values, m); 262 } 263 else if (attrName.equalsIgnoreCase(ATTR_RESTART_SERVER)) 264 { 265 r = parseBoolean(p, values, r); 266 } 267 } 268 269 shutdownMessage = m; 270 restartServer = r; 271 } 272 273 274 275 /** 276 * {@inheritDoc} 277 */ 278 @Override() 279 public String getTaskName() 280 { 281 return INFO_TASK_NAME_SHUTDOWN.get(); 282 } 283 284 285 286 /** 287 * {@inheritDoc} 288 */ 289 @Override() 290 public String getTaskDescription() 291 { 292 return INFO_TASK_DESCRIPTION_SHUTDOWN.get(); 293 } 294 295 296 297 /** 298 * Retrieves the shutdown message that may provide a reason for or additional 299 * information about the shutdown or restart. 300 * 301 * @return The shutdown message, or {@code null} if there is none. 302 */ 303 public String getShutdownMessage() 304 { 305 return shutdownMessage; 306 } 307 308 309 310 /** 311 * Indicates whether to attempt to restart the server rather than shut it 312 * down. 313 * 314 * @return {@code true} if the task should attempt to restart the server, or 315 * {@code false} if it should shut it down. 316 */ 317 public boolean restartServer() 318 { 319 return restartServer; 320 } 321 322 323 324 /** 325 * {@inheritDoc} 326 */ 327 @Override() 328 protected List<String> getAdditionalObjectClasses() 329 { 330 return Arrays.asList(OC_SHUTDOWN_TASK); 331 } 332 333 334 335 /** 336 * {@inheritDoc} 337 */ 338 @Override() 339 protected List<Attribute> getAdditionalAttributes() 340 { 341 final ArrayList<Attribute> attrs = new ArrayList<Attribute>(2); 342 343 if (shutdownMessage != null) 344 { 345 attrs.add(new Attribute(ATTR_SHUTDOWN_MESSAGE, shutdownMessage)); 346 } 347 348 attrs.add(new Attribute(ATTR_RESTART_SERVER, 349 String.valueOf(restartServer))); 350 351 return attrs; 352 } 353 354 355 356 /** 357 * {@inheritDoc} 358 */ 359 @Override() 360 public List<TaskProperty> getTaskSpecificProperties() 361 { 362 final List<TaskProperty> propList = Arrays.asList( 363 PROPERTY_SHUTDOWN_MESSAGE, 364 PROPERTY_RESTART_SERVER); 365 366 return Collections.unmodifiableList(propList); 367 } 368 369 370 371 /** 372 * {@inheritDoc} 373 */ 374 @Override() 375 public Map<TaskProperty,List<Object>> getTaskPropertyValues() 376 { 377 final LinkedHashMap<TaskProperty,List<Object>> props = 378 new LinkedHashMap<TaskProperty,List<Object>>(); 379 380 if (shutdownMessage == null) 381 { 382 props.put(PROPERTY_SHUTDOWN_MESSAGE, Collections.emptyList()); 383 } 384 else 385 { 386 props.put(PROPERTY_SHUTDOWN_MESSAGE, 387 Collections.<Object>unmodifiableList(Arrays.asList( 388 shutdownMessage))); 389 } 390 391 props.put(PROPERTY_RESTART_SERVER, 392 Collections.<Object>unmodifiableList(Arrays.asList( 393 restartServer))); 394 395 props.putAll(super.getTaskPropertyValues()); 396 return Collections.unmodifiableMap(props); 397 } 398 }