001    /*
002     * CDDL HEADER START
003     *
004     * The contents of this file are subject to the terms of the
005     * Common Development and Distribution License, Version 1.0 only
006     * (the "License").  You may not use this file except in compliance
007     * with the License.
008     *
009     * You can obtain a copy of the license at
010     * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011     * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012     * See the License for the specific language governing permissions
013     * and limitations under the License.
014     *
015     * When distributing Covered Code, include this CDDL HEADER in each
016     * file and include the License file at
017     * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
018     * add the following below this CDDL HEADER, with the fields enclosed
019     * by brackets "[]" replaced with your own identifying information:
020     *      Portions Copyright [yyyy] [name of copyright owner]
021     *
022     * CDDL HEADER END
023     *
024     *
025     *      Copyright 2008 Sun Microsystems, Inc.
026     */
027    
028    package org.opends.server.admin.client;
029    
030    
031    
032    import java.util.SortedSet;
033    
034    import org.opends.server.admin.AbstractManagedObjectDefinition;
035    import org.opends.server.admin.Configuration;
036    import org.opends.server.admin.ConfigurationClient;
037    import org.opends.server.admin.DefinitionDecodingException;
038    import org.opends.server.admin.InstantiableRelationDefinition;
039    import org.opends.server.admin.ManagedObjectNotFoundException;
040    import org.opends.server.admin.ManagedObjectPath;
041    import org.opends.server.admin.OptionalRelationDefinition;
042    import org.opends.server.admin.PropertyDefinition;
043    import org.opends.server.admin.PropertyException;
044    import org.opends.server.admin.client.spi.Driver;
045    import org.opends.server.admin.std.client.RootCfgClient;
046    
047    
048    
049    /**
050     * Client management connection context.
051     */
052    public abstract class ManagementContext {
053    
054      /**
055       * Creates a new management context.
056       */
057      protected ManagementContext() {
058        // No implementation required.
059      }
060    
061    
062    
063      /**
064       * Deletes the named instantiable child managed object from the
065       * named parent managed object.
066       *
067       * @param <C>
068       *          The type of client managed object configuration that the
069       *          relation definition refers to.
070       * @param <S>
071       *          The type of server managed object configuration that the
072       *          relation definition refers to.
073       * @param parent
074       *          The path of the parent managed object.
075       * @param rd
076       *          The instantiable relation definition.
077       * @param name
078       *          The name of the child managed object to be removed.
079       * @return Returns <code>true</code> if the named instantiable
080       *         child managed object was found, or <code>false</code>
081       *         if it was not found.
082       * @throws IllegalArgumentException
083       *           If the relation definition is not associated with the
084       *           parent managed object's definition.
085       * @throws ManagedObjectNotFoundException
086       *           If the parent managed object could not be found.
087       * @throws OperationRejectedException
088       *           If the managed object cannot be removed due to some
089       *           client-side or server-side constraint which cannot be
090       *           satisfied (for example, if it is referenced by another
091       *           managed object).
092       * @throws AuthorizationException
093       *           If the server refuses to remove the managed objects
094       *           because the client does not have the correct
095       *           privileges.
096       * @throws CommunicationException
097       *           If the client cannot contact the server due to an
098       *           underlying communication problem.
099       */
100      public final <C extends ConfigurationClient, S extends Configuration>
101      boolean deleteManagedObject(
102          ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd,
103          String name) throws IllegalArgumentException,
104          ManagedObjectNotFoundException, OperationRejectedException,
105          AuthorizationException, CommunicationException {
106        return getDriver().deleteManagedObject(parent, rd, name);
107      }
108    
109    
110    
111      /**
112       * Deletes the optional child managed object from the named parent
113       * managed object.
114       *
115       * @param <C>
116       *          The type of client managed object configuration that the
117       *          relation definition refers to.
118       * @param <S>
119       *          The type of server managed object configuration that the
120       *          relation definition refers to.
121       * @param parent
122       *          The path of the parent managed object.
123       * @param rd
124       *          The optional relation definition.
125       * @return Returns <code>true</code> if the optional child managed
126       *         object was found, or <code>false</code> if it was not
127       *         found.
128       * @throws IllegalArgumentException
129       *           If the relation definition is not associated with the
130       *           parent managed object's definition.
131       * @throws ManagedObjectNotFoundException
132       *           If the parent managed object could not be found.
133       * @throws OperationRejectedException
134       *           If the managed object cannot be removed due to some
135       *           client-side or server-side constraint which cannot be
136       *           satisfied (for example, if it is referenced by another
137       *           managed object).
138       * @throws AuthorizationException
139       *           If the server refuses to remove the managed objects
140       *           because the client does not have the correct
141       *           privileges.
142       * @throws CommunicationException
143       *           If the client cannot contact the server due to an
144       *           underlying communication problem.
145       */
146      public final <C extends ConfigurationClient, S extends Configuration>
147      boolean deleteManagedObject(
148          ManagedObjectPath<?, ?> parent, OptionalRelationDefinition<C, S> rd)
149          throws IllegalArgumentException, ManagedObjectNotFoundException,
150          OperationRejectedException, AuthorizationException,
151          CommunicationException {
152        return getDriver().deleteManagedObject(parent, rd);
153      }
154    
155    
156    
157      /**
158       * Gets the named managed object.
159       *
160       * @param <C>
161       *          The type of client managed object configuration that the
162       *          path definition refers to.
163       * @param <S>
164       *          The type of server managed object configuration that the
165       *          path definition refers to.
166       * @param path
167       *          The path of the managed object.
168       * @return Returns the named managed object.
169       * @throws DefinitionDecodingException
170       *           If the managed object was found but its type could not
171       *           be determined.
172       * @throws ManagedObjectDecodingException
173       *           If the managed object was found but one or more of its
174       *           properties could not be decoded.
175       * @throws ManagedObjectNotFoundException
176       *           If the requested managed object could not be found on
177       *           the server.
178       * @throws AuthorizationException
179       *           If the server refuses to retrieve the managed object
180       *           because the client does not have the correct
181       *           privileges.
182       * @throws CommunicationException
183       *           If the client cannot contact the server due to an
184       *           underlying communication problem.
185       */
186      @SuppressWarnings("unchecked")
187      public final <C extends ConfigurationClient, S extends Configuration>
188      ManagedObject<? extends C> getManagedObject(
189          ManagedObjectPath<C, S> path) throws DefinitionDecodingException,
190          ManagedObjectDecodingException, ManagedObjectNotFoundException,
191          AuthorizationException, CommunicationException {
192        // Be careful to handle the root configuration.
193        if (path.isEmpty()) {
194          return (ManagedObject<C>) getRootConfigurationManagedObject();
195        }
196    
197        return getDriver().getManagedObject(path);
198      }
199    
200    
201    
202      /**
203       * Gets the effective value of a property in the named managed
204       * object.
205       *
206       * @param <PD>
207       *          The type of the property to be retrieved.
208       * @param path
209       *          The path of the managed object containing the property.
210       * @param pd
211       *          The property to be retrieved.
212       * @return Returns the property's effective value, or
213       *         <code>null</code> if there are no values defined.
214       * @throws IllegalArgumentException
215       *           If the property definition is not associated with the
216       *           referenced managed object's definition.
217       * @throws DefinitionDecodingException
218       *           If the managed object was found but its type could not
219       *           be determined.
220       * @throws PropertyException
221       *           If the managed object was found but the requested
222       *           property could not be decoded.
223       * @throws ManagedObjectNotFoundException
224       *           If the requested managed object could not be found on
225       *           the server.
226       * @throws AuthorizationException
227       *           If the server refuses to retrieve the managed object
228       *           because the client does not have the correct
229       *           privileges.
230       * @throws CommunicationException
231       *           If the client cannot contact the server due to an
232       *           underlying communication problem.
233       */
234      public final <PD> PD getPropertyValue(ManagedObjectPath<?, ?> path,
235          PropertyDefinition<PD> pd) throws IllegalArgumentException,
236          DefinitionDecodingException, AuthorizationException,
237          ManagedObjectNotFoundException, CommunicationException,
238          PropertyException {
239        return getDriver().getPropertyValue(path, pd);
240      }
241    
242    
243    
244      /**
245       * Gets the effective values of a property in the named managed
246       * object.
247       *
248       * @param <PD>
249       *          The type of the property to be retrieved.
250       * @param path
251       *          The path of the managed object containing the property.
252       * @param pd
253       *          The property to be retrieved.
254       * @return Returns the property's effective values, or an empty set
255       *         if there are no values defined.
256       * @throws IllegalArgumentException
257       *           If the property definition is not associated with the
258       *           referenced managed object's definition.
259       * @throws DefinitionDecodingException
260       *           If the managed object was found but its type could not
261       *           be determined.
262       * @throws PropertyException
263       *           If the managed object was found but the requested
264       *           property could not be decoded.
265       * @throws ManagedObjectNotFoundException
266       *           If the requested managed object could not be found on
267       *           the server.
268       * @throws AuthorizationException
269       *           If the server refuses to retrieve the managed object
270       *           because the client does not have the correct
271       *           privileges.
272       * @throws CommunicationException
273       *           If the client cannot contact the server due to an
274       *           underlying communication problem.
275       */
276      public final <PD> SortedSet<PD> getPropertyValues(
277          ManagedObjectPath<?, ?> path, PropertyDefinition<PD> pd)
278          throws IllegalArgumentException, DefinitionDecodingException,
279          AuthorizationException, ManagedObjectNotFoundException,
280          CommunicationException, PropertyException {
281        return getDriver().getPropertyValues(path, pd);
282      }
283    
284    
285    
286      /**
287       * Gets the root configuration client associated with this
288       * management context.
289       *
290       * @return Returns the root configuration client associated with
291       *         this management context.
292       */
293      public final RootCfgClient getRootConfiguration() {
294        return getRootConfigurationManagedObject().getConfiguration();
295      }
296    
297    
298    
299      /**
300       * Gets the root configuration managed object associated with this
301       * management context.
302       *
303       * @return Returns the root configuration managed object associated
304       *         with this management context.
305       */
306      public final
307      ManagedObject<RootCfgClient> getRootConfigurationManagedObject() {
308        return getDriver().getRootConfigurationManagedObject();
309      }
310    
311    
312    
313      /**
314       * Lists the child managed objects of the named parent managed
315       * object.
316       *
317       * @param <C>
318       *          The type of client managed object configuration that the
319       *          relation definition refers to.
320       * @param <S>
321       *          The type of server managed object configuration that the
322       *          relation definition refers to.
323       * @param parent
324       *          The path of the parent managed object.
325       * @param rd
326       *          The instantiable relation definition.
327       * @return Returns the names of the child managed objects.
328       * @throws IllegalArgumentException
329       *           If the relation definition is not associated with the
330       *           parent managed object's definition.
331       * @throws ManagedObjectNotFoundException
332       *           If the parent managed object could not be found.
333       * @throws AuthorizationException
334       *           If the server refuses to list the managed objects
335       *           because the client does not have the correct
336       *           privileges.
337       * @throws CommunicationException
338       *           If the client cannot contact the server due to an
339       *           underlying communication problem.
340       */
341      public final <C extends ConfigurationClient, S extends Configuration>
342      String[] listManagedObjects(
343          ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd)
344          throws IllegalArgumentException, ManagedObjectNotFoundException,
345          AuthorizationException, CommunicationException {
346        return getDriver().listManagedObjects(parent, rd);
347      }
348    
349    
350    
351      /**
352       * Lists the child managed objects of the named parent managed
353       * object which are a sub-type of the specified managed object
354       * definition.
355       *
356       * @param <C>
357       *          The type of client managed object configuration that the
358       *          relation definition refers to.
359       * @param <S>
360       *          The type of server managed object configuration that the
361       *          relation definition refers to.
362       * @param parent
363       *          The path of the parent managed object.
364       * @param rd
365       *          The instantiable relation definition.
366       * @param d
367       *          The managed object definition.
368       * @return Returns the names of the child managed objects which are
369       *         a sub-type of the specified managed object definition.
370       * @throws IllegalArgumentException
371       *           If the relation definition is not associated with the
372       *           parent managed object's definition.
373       * @throws ManagedObjectNotFoundException
374       *           If the parent managed object could not be found.
375       * @throws AuthorizationException
376       *           If the server refuses to list the managed objects
377       *           because the client does not have the correct
378       *           privileges.
379       * @throws CommunicationException
380       *           If the client cannot contact the server due to an
381       *           underlying communication problem.
382       */
383      public final <C extends ConfigurationClient, S extends Configuration>
384      String[] listManagedObjects(
385          ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd,
386          AbstractManagedObjectDefinition<? extends C, ? extends S> d)
387          throws IllegalArgumentException, ManagedObjectNotFoundException,
388          AuthorizationException, CommunicationException {
389        return getDriver().listManagedObjects(parent, rd, d);
390      }
391    
392    
393    
394      /**
395       * Determines whether or not the named managed object exists.
396       *
397       * @param path
398       *          The path of the named managed object.
399       * @return Returns <code>true</code> if the named managed object
400       *         exists, <code>false</code> otherwise.
401       * @throws ManagedObjectNotFoundException
402       *           If the parent managed object could not be found.
403       * @throws AuthorizationException
404       *           If the server refuses to make the determination because
405       *           the client does not have the correct privileges.
406       * @throws CommunicationException
407       *           If the client cannot contact the server due to an
408       *           underlying communication problem.
409       */
410      public final boolean managedObjectExists(ManagedObjectPath<?, ?> path)
411          throws ManagedObjectNotFoundException, AuthorizationException,
412          CommunicationException {
413        return getDriver().managedObjectExists(path);
414      }
415    
416    
417    
418      /**
419       * Gets the driver associated with this management context.
420       *
421       * @return Returns the driver associated with this management
422       *         context.
423       */
424      protected abstract Driver getDriver();
425    
426    
427    
428      /**
429       * Closes this management context.
430       */
431      public final void close() {
432        this.getDriver().close();
433      }
434    
435    }