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.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 add the
051     * contents of one or more files to the server schema.  The properties that are
052     * available for use with this type of task include:
053     * <UL>
054     *   <LI>The names of the files to add to the server schema.  The specified
055     *       files must exist within the server's schema configuration directory
056     *       with the appropriate schema elements defined.  They should be only the
057     *       base names for the file and should not include any path
058     *       information.  At least one name must be provided.</LI>
059     * </UL>
060     */
061    @NotMutable()
062    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
063    public final class AddSchemaFileTask
064           extends Task
065    {
066      /**
067       * The fully-qualified name of the Java class that is used for the add schema
068       * file task.
069       */
070      static final String ADD_SCHEMA_FILE_TASK_CLASS =
071           "com.unboundid.directory.server.tasks.AddSchemaFileTask";
072    
073    
074    
075      /**
076       * The name of the attribute used to specify the name(s) of the schema file(s)
077       * to add.
078       */
079      private static final String ATTR_SCHEMA_FILE =
080           "ds-task-schema-file-name";
081    
082    
083    
084      /**
085       * The name of the object class used in add schema file task entries.
086       */
087      private static final String OC_ADD_SCHEMA_FILE_TASK =
088           "ds-task-add-schema-file";
089    
090    
091    
092      /**
093       * The task property that will be used for the schema file names.
094       */
095      private static final TaskProperty PROPERTY_SCHEMA_FILE =
096         new TaskProperty(ATTR_SCHEMA_FILE, INFO_DISPLAY_NAME_SCHEMA_FILE.get(),
097                          INFO_DESCRIPTION_SCHEMA_FILE.get(), String.class, true,
098                          true, false);
099    
100    
101    
102    
103      /**
104       * The serial version UID for this serializable class.
105       */
106      private static final long serialVersionUID = -5430392768265418966L;
107    
108    
109    
110      // The names of the schema files to be added.
111      private final List<String> schemaFileNames;
112    
113    
114    
115      /**
116       * Creates a new uninitialized add schema file task instance which should only
117       * be used for obtaining general information about this task, including the
118       * task name, description, and supported properties.  Attempts to use a task
119       * created with this constructor for any other reason will likely fail.
120       */
121      public AddSchemaFileTask()
122      {
123        schemaFileNames = null;
124      }
125    
126    
127    
128    
129      /**
130       * Creates a new add schema file task to add the specified file to the server
131       * schema.
132       *
133       * @param  taskID          The task ID to use for this task.  If it is
134       *                         {@code null} then a UUID will be generated for use
135       *                         as the task ID.
136       * @param  schemaFileName  The name (without path information) of the file to
137       *                         add to the server schema.  It must not be
138       *                         {@code null}.
139       */
140      public AddSchemaFileTask(final String taskID, final String schemaFileName)
141      {
142        this(taskID, Arrays.asList(schemaFileName), null, null, null, null, null);
143    
144        ensureNotNull(schemaFileName);
145      }
146    
147    
148    
149    
150      /**
151       * Creates a new add schema file task to add the specified files to the server
152       * schema.
153       *
154       * @param  taskID           The task ID to use for this task.  If it is
155       *                          {@code null} then a UUID will be generated for use
156       *                          as the task ID.
157       * @param  schemaFileNames  The list of names (without path information) of
158       *                          the files to add to the server schema.  It must
159       *                          not be {@code null} or empty.
160       */
161      public AddSchemaFileTask(final String taskID,
162                               final List<String> schemaFileNames)
163      {
164        this(taskID, schemaFileNames, null, null, null, null, null);
165      }
166    
167    
168    
169      /**
170       * Creates a new add schema file task to add the specified files to the server
171       * schema.
172       *
173       * @param  taskID                  The task ID to use for this task.  If it is
174       *                                 {@code null} then a UUID will be generated
175       *                                 for use as the task ID.
176       * @param  schemaFileNames         The list of names (without path
177       *                                 information) of the files to add to the
178       *                                 server schema.  It must not be {@code null}
179       *                                 or empty.
180       * @param  scheduledStartTime      The time that this task should start
181       *                                 running.
182       * @param  dependencyIDs           The list of task IDs that will be required
183       *                                 to complete before this task will be
184       *                                 eligible to start.
185       * @param  failedDependencyAction  Indicates what action should be taken if
186       *                                 any of the dependencies for this task do
187       *                                 not complete successfully.
188       * @param  notifyOnCompletion      The list of e-mail addresses of individuals
189       *                                 that should be notified when this task
190       *                                 completes.
191       * @param  notifyOnError           The list of e-mail addresses of individuals
192       *                                 that should be notified if this task does
193       *                                 not complete successfully.
194       */
195      public AddSchemaFileTask(final String taskID,
196                               final List<String> schemaFileNames,
197                               final Date scheduledStartTime,
198                               final List<String> dependencyIDs,
199                               final FailedDependencyAction failedDependencyAction,
200                               final List<String> notifyOnCompletion,
201                               final List<String> notifyOnError)
202      {
203        super(taskID, ADD_SCHEMA_FILE_TASK_CLASS, scheduledStartTime,
204              dependencyIDs, failedDependencyAction, notifyOnCompletion,
205              notifyOnError);
206    
207        ensureNotNull(schemaFileNames);
208        ensureFalse(schemaFileNames.isEmpty(),
209                    "AddSchemaFileTask.schemaFileNames must not be empty.");
210    
211        this.schemaFileNames = Collections.unmodifiableList(schemaFileNames);
212      }
213    
214    
215    
216      /**
217       * Creates a new add schema file task from the provided entry.
218       *
219       * @param  entry  The entry to use to create this add schema file task.
220       *
221       * @throws  TaskException  If the provided entry cannot be parsed as a
222       *                         add schema file task entry.
223       */
224      public AddSchemaFileTask(final Entry entry)
225             throws TaskException
226      {
227        super(entry);
228    
229        // Get the set of schema file names.  It must be present.
230        final String[] fileNames = entry.getAttributeValues(ATTR_SCHEMA_FILE);
231        if ((fileNames == null) || (fileNames.length == 0))
232        {
233          throw new TaskException(ERR_ADD_SCHEMA_FILE_TASK_NO_FILES.get(
234                                       getTaskEntryDN()));
235        }
236    
237        schemaFileNames = Collections.unmodifiableList(Arrays.asList(fileNames));
238      }
239    
240    
241    
242      /**
243       * Creates a new add schema file task from the provided set of task
244       * properties.
245       *
246       * @param  properties  The set of task properties and their corresponding
247       *                     values to use for the task.  It must not be
248       *                     {@code null}.
249       *
250       * @throws  TaskException  If the provided set of properties cannot be used to
251       *                         create a valid add schema file task.
252       */
253      public AddSchemaFileTask(final Map<TaskProperty,List<Object>> properties)
254             throws TaskException
255      {
256        super(ADD_SCHEMA_FILE_TASK_CLASS, properties);
257    
258        String[] names = null;
259        for (final Map.Entry<TaskProperty,List<Object>> entry :
260             properties.entrySet())
261        {
262          final TaskProperty p = entry.getKey();
263          final String attrName = p.getAttributeName();
264          final List<Object> values = entry.getValue();
265    
266          if (attrName.equalsIgnoreCase(ATTR_SCHEMA_FILE))
267          {
268            names = parseStrings(p, values, names);
269          }
270        }
271    
272        if (names == null)
273        {
274          throw new TaskException(ERR_ADD_SCHEMA_FILE_TASK_NO_FILES.get(
275                                       getTaskEntryDN()));
276        }
277    
278        schemaFileNames = Collections.unmodifiableList(Arrays.asList(names));
279      }
280    
281    
282    
283      /**
284       * {@inheritDoc}
285       */
286      @Override()
287      public String getTaskName()
288      {
289        return INFO_TASK_NAME_ADD_SCHEMA_FILE.get();
290      }
291    
292    
293    
294      /**
295       * {@inheritDoc}
296       */
297      @Override()
298      public String getTaskDescription()
299      {
300        return INFO_TASK_DESCRIPTION_ADD_SCHEMA_FILE.get();
301      }
302    
303    
304    
305      /**
306       * Retrieves the names (without path information) of the schema files to be
307       * added to the server.
308       *
309       * @return  The names of the schema files to be added to the server.
310       */
311      public List<String> getSchemaFileNames()
312      {
313        return schemaFileNames;
314      }
315    
316    
317    
318      /**
319       * {@inheritDoc}
320       */
321      @Override()
322      protected List<String> getAdditionalObjectClasses()
323      {
324        return Arrays.asList(OC_ADD_SCHEMA_FILE_TASK);
325      }
326    
327    
328    
329      /**
330       * {@inheritDoc}
331       */
332      @Override()
333      protected List<Attribute> getAdditionalAttributes()
334      {
335        return Arrays.asList(new Attribute(ATTR_SCHEMA_FILE, schemaFileNames));
336      }
337    
338    
339    
340      /**
341       * {@inheritDoc}
342       */
343      @Override()
344      public List<TaskProperty> getTaskSpecificProperties()
345      {
346        return Collections.unmodifiableList(Arrays.asList(PROPERTY_SCHEMA_FILE));
347      }
348    
349    
350    
351      /**
352       * {@inheritDoc}
353       */
354      @Override()
355      public Map<TaskProperty,List<Object>> getTaskPropertyValues()
356      {
357        final LinkedHashMap<TaskProperty,List<Object>> props =
358             new LinkedHashMap<TaskProperty,List<Object>>();
359    
360        props.put(PROPERTY_SCHEMA_FILE,
361                  Collections.<Object>unmodifiableList(schemaFileNames));
362    
363        props.putAll(super.getTaskPropertyValues());
364        return Collections.unmodifiableMap(props);
365      }
366    }