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 import static com.unboundid.util.Validator.*;
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 Directory Server task that can be used to restore a
052 * backup. The properties that are available for use with this type of task
053 * include:
054 * <UL>
055 * <LI>The path to the backup directory in which the backup resides. This
056 * must be provided when scheduling a new task of this type.</LI>
057 * <LI>The backup ID of the backup to be restored. If this is not provided
058 * when scheduling an instance of this task, then the most recent backup
059 * in the backup directory will be selected.</LI>
060 * <LI>A flag that indicates whether to attempt to restore the backup or
061 * only to verify it to determine whether it appears to be valid (e.g.,
062 * validate the digest and/or signature, make sure that the backend
063 * considers it valid, etc.).</LI>
064 * </UL>
065
066 */
067 @NotMutable()
068 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
069 public final class RestoreTask
070 extends Task
071 {
072 /**
073 * The fully-qualified name of the Java class that is used for the restore
074 * task.
075 */
076 static final String RESTORE_TASK_CLASS =
077 "com.unboundid.directory.server.tasks.RestoreTask";
078
079
080
081 /**
082 * The name of the attribute used to specify the path to the backup directory
083 * containing the backup to restore.
084 */
085 private static final String ATTR_BACKUP_DIRECTORY =
086 "ds-backup-directory-path";
087
088
089
090 /**
091 * The name of the attribute used to specify the backup ID of the backup to
092 * restore.
093 */
094 private static final String ATTR_BACKUP_ID = "ds-backup-id";
095
096
097
098 /**
099 * The name of the attribute used to indicate whether to only verify the
100 * backup but not actually restore it.
101 */
102 private static final String ATTR_VERIFY_ONLY =
103 "ds-task-restore-verify-only";
104
105
106
107 /**
108 * The name of the object class used in restore task entries.
109 */
110 private static final String OC_RESTORE_TASK = "ds-task-restore";
111
112
113
114 /**
115 * The task property for the backup directory.
116 */
117 private static final TaskProperty PROPERTY_BACKUP_DIRECTORY =
118 new TaskProperty(ATTR_BACKUP_DIRECTORY,
119 INFO_DISPLAY_NAME_BACKUP_DIRECTORY.get(),
120 INFO_DESCRIPTION_BACKUP_DIRECTORY_RESTORE.get(),
121 String.class, true, false, false);
122
123
124
125 /**
126 * The task property for the backup ID.
127 */
128 private static final TaskProperty PROPERTY_BACKUP_ID =
129 new TaskProperty(ATTR_BACKUP_ID, INFO_DISPLAY_NAME_BACKUP_ID.get(),
130 INFO_DESCRIPTION_BACKUP_ID_RESTORE.get(), String.class,
131 false, false, true);
132
133
134
135 /**
136 * The task property for the verify only flag.
137 */
138 private static final TaskProperty PROPERTY_VERIFY_ONLY =
139 new TaskProperty(ATTR_VERIFY_ONLY, INFO_DISPLAY_NAME_VERIFY_ONLY.get(),
140 INFO_DESCRIPTION_VERIFY_ONLY.get(), Boolean.class,
141 false, false, false);
142
143
144
145 /**
146 * The serial version UID for this serializable class.
147 */
148 private static final long serialVersionUID = -196339437379274643L;
149
150
151
152 // Indicates whether to only verify the backup without restoring it.
153 private final boolean verifyOnly;
154
155 // The path to the backup directory containing the backup to restore.
156 private final String backupDirectory;
157
158 // The backup ID of the backup to restore.
159 private final String backupID;
160
161
162
163 /**
164 * Creates a new uninitialized restore task instance which should only be used
165 * for obtaining general information about this task, including the task name,
166 * description, and supported properties. Attempts to use a task created with
167 * this constructor for any other reason will likely fail.
168 */
169 public RestoreTask()
170 {
171 verifyOnly = false;
172 backupDirectory = null;
173 backupID = null;
174 }
175
176
177
178
179 /**
180 * Creates a new restore task with the provided information.
181 *
182 * @param taskID The task ID to use for this task. If it is
183 * {@code null} then a UUID will be generated for use
184 * as the task ID.
185 * @param backupDirectory The path to the directory on the server containing
186 * the backup to restore. It may be an absolute path
187 * or relative to the server root directory. It must
188 * not be {@code null}.
189 * @param backupID The backup ID of the backup to restore. If this
190 * is {@code null} then the most recent backup in the
191 * specified backup directory will be restored.
192 * @param verifyOnly Indicates whether to only verify the backup
193 * without restoring it.
194 */
195 public RestoreTask(final String taskID, final String backupDirectory,
196 final String backupID, final boolean verifyOnly)
197 {
198 this(taskID, backupDirectory, backupID, verifyOnly, null, null, null, null,
199 null);
200 }
201
202
203
204 /**
205 * Creates a new restore task with the provided information.
206 *
207 * @param taskID The task ID to use for this task. If it is
208 * {@code null} then a UUID will be generated
209 * for use as the task ID.
210 * @param backupDirectory The path to the directory on the server
211 * containing the backup to restore. It may
212 * be an absolute path or relative to the
213 * server root directory. It must not be
214 * {@code null}.
215 * @param backupID The backup ID of the backup to restore. If
216 * this is {@code null} then the most recent
217 * backup in the specified backup directory
218 * will be restored.
219 * @param verifyOnly Indicates whether to only verify the backup
220 * without restoring it.
221 * @param scheduledStartTime The time that this task should start
222 * running.
223 * @param dependencyIDs The list of task IDs that will be required
224 * to complete before this task will be
225 * eligible to start.
226 * @param failedDependencyAction Indicates what action should be taken if
227 * any of the dependencies for this task do
228 * not complete successfully.
229 * @param notifyOnCompletion The list of e-mail addresses of individuals
230 * that should be notified when this task
231 * completes.
232 * @param notifyOnError The list of e-mail addresses of individuals
233 * that should be notified if this task does
234 * not complete successfully.
235 */
236 public RestoreTask(final String taskID, final String backupDirectory,
237 final String backupID, final boolean verifyOnly,
238 final Date scheduledStartTime,
239 final List<String> dependencyIDs,
240 final FailedDependencyAction failedDependencyAction,
241 final List<String> notifyOnCompletion,
242 final List<String> notifyOnError)
243 {
244 super(taskID, RESTORE_TASK_CLASS, scheduledStartTime,
245 dependencyIDs, failedDependencyAction, notifyOnCompletion,
246 notifyOnError);
247
248 ensureNotNull(backupDirectory);
249
250 this.backupDirectory = backupDirectory;
251 this.backupID = backupID;
252 this.verifyOnly = verifyOnly;
253 }
254
255
256
257 /**
258 * Creates a new restore task from the provided entry.
259 *
260 * @param entry The entry to use to create this restore task.
261 *
262 * @throws TaskException If the provided entry cannot be parsed as a restore
263 * task entry.
264 */
265 public RestoreTask(final Entry entry)
266 throws TaskException
267 {
268 super(entry);
269
270
271 // Get the backup directory. It must be present.
272 backupDirectory = entry.getAttributeValue(ATTR_BACKUP_DIRECTORY);
273 if (backupDirectory == null)
274 {
275 throw new TaskException(ERR_RESTORE_NO_BACKUP_DIRECTORY.get(
276 getTaskEntryDN()));
277 }
278
279
280 // Get the backup ID. It may be absent.
281 backupID = entry.getAttributeValue(ATTR_BACKUP_ID);
282
283
284 // Get the verifyOnly flag. It may be absent.
285 verifyOnly = parseBooleanValue(entry, ATTR_VERIFY_ONLY, false);
286 }
287
288
289
290 /**
291 * Creates a new restore task from the provided set of task properties.
292 *
293 * @param properties The set of task properties and their corresponding
294 * values to use for the task. It must not be
295 * {@code null}.
296 *
297 * @throws TaskException If the provided set of properties cannot be used to
298 * create a valid restore task.
299 */
300 public RestoreTask(final Map<TaskProperty,List<Object>> properties)
301 throws TaskException
302 {
303 super(RESTORE_TASK_CLASS, properties);
304
305 boolean v = false;
306 String b = null;
307 String i = null;
308
309 for (final Map.Entry<TaskProperty,List<Object>> entry :
310 properties.entrySet())
311 {
312 final TaskProperty p = entry.getKey();
313 final String attrName = p.getAttributeName();
314 final List<Object> values = entry.getValue();
315
316 if (attrName.equalsIgnoreCase(ATTR_BACKUP_DIRECTORY))
317 {
318 b = parseString(p, values, b);
319 }
320 else if (attrName.equalsIgnoreCase(ATTR_BACKUP_ID))
321 {
322 i = parseString(p, values, i);
323 }
324 else if (attrName.equalsIgnoreCase(ATTR_VERIFY_ONLY))
325 {
326 v = parseBoolean(p, values, v);
327 }
328 }
329
330 if (b == null)
331 {
332 throw new TaskException(ERR_RESTORE_NO_BACKUP_DIRECTORY.get(
333 getTaskEntryDN()));
334 }
335
336 backupDirectory = b;
337 backupID = i;
338 verifyOnly = v;
339 }
340
341
342
343 /**
344 * {@inheritDoc}
345 */
346 @Override()
347 public String getTaskName()
348 {
349 return INFO_TASK_NAME_RESTORE.get();
350 }
351
352
353
354 /**
355 * {@inheritDoc}
356 */
357 @Override()
358 public String getTaskDescription()
359 {
360 return INFO_TASK_DESCRIPTION_RESTORE.get();
361 }
362
363
364
365 /**
366 * Retrieves the path to the backup directory which contains the backup to
367 * restore. It may be either an absolute path or one that is relative to the
368 * server root.
369 *
370 * @return The path to the backup directory which contains the backup to
371 * restore.
372 */
373 public String getBackupDirectory()
374 {
375 return backupDirectory;
376 }
377
378
379
380 /**
381 * Retrieves the backup ID of the backup to restore.
382 *
383 * @return The backup ID of the backup to restore, or {@code null} if the
384 * most recent backup in the backup directory should be restored.
385 */
386 public String getBackupID()
387 {
388 return backupID;
389 }
390
391
392
393 /**
394 * Indicates whether the backup should only be verified without actually being
395 * restored.
396 *
397 * @return {@code true} if the backup should be verified but not restored, or
398 * {@code false} if it should be restored.
399 */
400 public boolean verifyOnly()
401 {
402 return verifyOnly;
403 }
404
405
406
407 /**
408 * {@inheritDoc}
409 */
410 @Override()
411 protected List<String> getAdditionalObjectClasses()
412 {
413 return Arrays.asList(OC_RESTORE_TASK);
414 }
415
416
417
418 /**
419 * {@inheritDoc}
420 */
421 @Override()
422 protected List<Attribute> getAdditionalAttributes()
423 {
424 final ArrayList<Attribute> attrs = new ArrayList<Attribute>(3);
425
426 attrs.add(new Attribute(ATTR_BACKUP_DIRECTORY, backupDirectory));
427 attrs.add(new Attribute(ATTR_VERIFY_ONLY, String.valueOf(verifyOnly)));
428
429 if (backupID != null)
430 {
431 attrs.add(new Attribute(ATTR_BACKUP_ID, backupID));
432 }
433
434 return attrs;
435 }
436
437
438
439 /**
440 * {@inheritDoc}
441 */
442 @Override()
443 public List<TaskProperty> getTaskSpecificProperties()
444 {
445 final List<TaskProperty> propList = Arrays.asList(
446 PROPERTY_BACKUP_DIRECTORY,
447 PROPERTY_BACKUP_ID,
448 PROPERTY_VERIFY_ONLY);
449
450 return Collections.unmodifiableList(propList);
451 }
452
453
454
455 /**
456 * {@inheritDoc}
457 */
458 @Override()
459 public Map<TaskProperty,List<Object>> getTaskPropertyValues()
460 {
461 final LinkedHashMap<TaskProperty,List<Object>> props =
462 new LinkedHashMap<TaskProperty,List<Object>>();
463
464 props.put(PROPERTY_BACKUP_DIRECTORY,
465 Collections.<Object>unmodifiableList(Arrays.asList(backupDirectory)));
466
467 if (backupID == null)
468 {
469 props.put(PROPERTY_BACKUP_ID, Collections.emptyList());
470 }
471 else
472 {
473 props.put(PROPERTY_BACKUP_ID,
474 Collections.<Object>unmodifiableList(Arrays.asList(backupID)));
475 }
476
477 props.put(PROPERTY_VERIFY_ONLY,
478 Collections.<Object>unmodifiableList(Arrays.asList(verifyOnly)));
479
480 props.putAll(super.getTaskPropertyValues());
481 return Collections.unmodifiableMap(props);
482 }
483 }