001 /*
002 * Copyright 2010-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.Collections;
027 import java.util.Date;
028 import java.util.LinkedHashMap;
029 import java.util.List;
030 import java.util.Map;
031
032 import com.unboundid.ldap.sdk.Attribute;
033 import com.unboundid.ldap.sdk.Entry;
034 import com.unboundid.util.NotMutable;
035 import com.unboundid.util.ThreadSafety;
036 import com.unboundid.util.ThreadSafetyLevel;
037
038 import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*;
039 import static com.unboundid.util.Validator.*;
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 dump
051 * information about the contents of a backend which stores its data in a
052 * Berkeley DB Java Edition database. It reports information about the total
053 * number of keys, total and average key size, and total an average value size
054 * for all of the databases in the environment, and the percentage of the total
055 * live data size contained in each database.
056 * <BR><BR>
057 * The properties that are available for use with this type of task include:
058 * <UL>
059 * <LI>The backend ID of the backend for to be examined. The specified
060 * backend must be enabled and must store its contents in the Berkeley DB
061 * Java Edition.</LI>
062 * </UL>
063 */
064 @NotMutable()
065 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
066 public final class DumpDBDetailsTask
067 extends Task
068 {
069 /**
070 * The fully-qualified name of the Java class that is used for the dump DB
071 * details task.
072 */
073 static final String DUMP_DB_DETAILS_TASK_CLASS =
074 "com.unboundid.directory.server.tasks.DumpDBDetailsTask";
075
076
077
078 /**
079 * The name of the attribute used to specify the backend ID of the target
080 * backend.
081 */
082 private static final String ATTR_BACKEND_ID =
083 "ds-task-dump-db-backend-id";
084
085
086
087 /**
088 * The name of the object class used in dump DB details task entries.
089 */
090 private static final String OC_DUMP_DB_DETAILS_TASK = "ds-task-dump-db";
091
092
093
094 /**
095 * The task property that will be used for the backend ID.
096 */
097 private static final TaskProperty PROPERTY_BACKEND_ID =
098 new TaskProperty(ATTR_BACKEND_ID,
099 INFO_DUMP_DB_DISPLAY_NAME_BACKEND_ID.get(),
100 INFO_DUMP_DB_DESCRIPTION_BACKEND_ID.get(), String.class, true,
101 false, false);
102
103
104
105 /**
106 * The serial version UID for this serializable class.
107 */
108 private static final long serialVersionUID = 7267871080385864231L;
109
110
111
112 // The name of the backend to be examined.
113 private final String backendID;
114
115
116
117 /**
118 * Creates a new uninitialized dump DB details task instance which should only
119 * be used for obtaining general information about this task, including the
120 * task name, description, and supported properties. Attempts to use a task
121 * created with this constructor for any other reason will likely fail.
122 */
123 public DumpDBDetailsTask()
124 {
125 backendID = null;
126 }
127
128
129
130
131 /**
132 * Creates a new dump DB details task to examine the specified backend.
133 *
134 * @param taskID The task ID to use for this task. If it is {@code null}
135 * then a UUID will be generated for use as the task ID.
136 * @param backendID The backend ID for the backend to examine. It must not
137 * be {@code null}.
138 */
139 public DumpDBDetailsTask(final String taskID, final String backendID)
140 {
141 this(taskID, backendID, null, null, null, null, null);
142 }
143
144
145
146 /**
147 * Creates a new dump DB details task to examine the specified backend.
148 *
149 * @param taskID The task ID to use for this task. If it is
150 * {@code null} then a UUID will be generated
151 * for use as the task ID.
152 * @param backendID The backend ID for the backend to examine.
153 * It must not be {@code null}.
154 * @param scheduledStartTime The time that this task should start
155 * running.
156 * @param dependencyIDs The list of task IDs that will be required
157 * to complete before this task will be
158 * eligible to start.
159 * @param failedDependencyAction Indicates what action should be taken if
160 * any of the dependencies for this task do
161 * not complete successfully.
162 * @param notifyOnCompletion The list of e-mail addresses of individuals
163 * that should be notified when this task
164 * completes.
165 * @param notifyOnError The list of e-mail addresses of individuals
166 * that should be notified if this task does
167 * not complete successfully.
168 */
169 public DumpDBDetailsTask(final String taskID, final String backendID,
170 final Date scheduledStartTime,
171 final List<String> dependencyIDs,
172 final FailedDependencyAction failedDependencyAction,
173 final List<String> notifyOnCompletion,
174 final List<String> notifyOnError)
175 {
176 super(taskID, DUMP_DB_DETAILS_TASK_CLASS, scheduledStartTime, dependencyIDs,
177 failedDependencyAction, notifyOnCompletion, notifyOnError);
178
179 ensureNotNull(backendID);
180
181 this.backendID = backendID;
182 }
183
184
185
186 /**
187 * Creates a new dump DB details task from the provided entry.
188 *
189 * @param entry The entry to use to create this dump DB details task.
190 *
191 * @throws TaskException If the provided entry cannot be parsed as a dump DB
192 * details task entry.
193 */
194 public DumpDBDetailsTask(final Entry entry)
195 throws TaskException
196 {
197 super(entry);
198
199 // Get the backend ID. It must be present.
200 backendID = entry.getAttributeValue(ATTR_BACKEND_ID);
201 if (backendID == null)
202 {
203 throw new TaskException(ERR_DUMP_DB_ENTRY_MISSING_BACKEND_ID.get(
204 getTaskEntryDN(), ATTR_BACKEND_ID));
205 }
206 }
207
208
209
210 /**
211 * Creates a new dump DB details task from the provided set of task
212 * properties.
213 *
214 * @param properties The set of task properties and their corresponding
215 * values to use for the task. It must not be
216 * {@code null}.
217 *
218 * @throws TaskException If the provided set of properties cannot be used to
219 * create a valid dump DB details task.
220 */
221 public DumpDBDetailsTask(final Map<TaskProperty,List<Object>> properties)
222 throws TaskException
223 {
224 super(DUMP_DB_DETAILS_TASK_CLASS, properties);
225
226 String id = null;
227 for (final Map.Entry<TaskProperty,List<Object>> entry :
228 properties.entrySet())
229 {
230 final TaskProperty p = entry.getKey();
231 final String attrName = p.getAttributeName();
232 final List<Object> values = entry.getValue();
233
234 if (attrName.equalsIgnoreCase(ATTR_BACKEND_ID))
235 {
236 id = parseString(p, values, id);
237 }
238 }
239
240 if (id == null)
241 {
242 throw new TaskException(ERR_DUMP_DB_ENTRY_MISSING_BACKEND_ID.get(
243 getTaskEntryDN(), ATTR_BACKEND_ID));
244 }
245
246 backendID = id;
247 }
248
249
250
251 /**
252 * {@inheritDoc}
253 */
254 @Override()
255 public String getTaskName()
256 {
257 return INFO_TASK_NAME_DUMP_DB.get();
258 }
259
260
261
262 /**
263 * {@inheritDoc}
264 */
265 @Override()
266 public String getTaskDescription()
267 {
268 return INFO_TASK_DESCRIPTION_DUMP_DB.get();
269 }
270
271
272
273 /**
274 * Retrieves the backend ID of the backend to examine.
275 *
276 * @return The backend ID of the backend to examine.
277 */
278 public String getBackendID()
279 {
280 return backendID;
281 }
282
283
284
285 /**
286 * {@inheritDoc}
287 */
288 @Override()
289 protected List<String> getAdditionalObjectClasses()
290 {
291 return Arrays.asList(OC_DUMP_DB_DETAILS_TASK);
292 }
293
294
295
296 /**
297 * {@inheritDoc}
298 */
299 @Override()
300 protected List<Attribute> getAdditionalAttributes()
301 {
302 return Arrays.asList(new Attribute(ATTR_BACKEND_ID, backendID));
303 }
304
305
306
307 /**
308 * {@inheritDoc}
309 */
310 @Override()
311 public List<TaskProperty> getTaskSpecificProperties()
312 {
313 return Collections.unmodifiableList(Arrays.asList(PROPERTY_BACKEND_ID));
314 }
315
316
317
318 /**
319 * {@inheritDoc}
320 */
321 @Override()
322 public Map<TaskProperty,List<Object>> getTaskPropertyValues()
323 {
324 final LinkedHashMap<TaskProperty,List<Object>> props =
325 new LinkedHashMap<TaskProperty,List<Object>>(1);
326
327 props.put(PROPERTY_BACKEND_ID, Collections.<Object>unmodifiableList(
328 Arrays.asList(backendID)));
329
330 props.putAll(super.getTaskPropertyValues());
331 return Collections.unmodifiableMap(props);
332 }
333 }