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 2006-2008 Sun Microsystems, Inc.
026     */
027    package org.opends.server.api.plugin;
028    import org.opends.messages.Message;
029    
030    
031    
032    import java.util.List;
033    import java.util.Set;
034    
035    import org.opends.server.admin.std.server.PluginCfg;
036    import org.opends.server.api.ClientConnection;
037    import org.opends.server.config.ConfigException;
038    import org.opends.server.types.*;
039    import org.opends.server.types.operation.*;
040    
041    import static org.opends.messages.PluginMessages.*;
042    
043    
044    /**
045     * This class defines the set of methods and structures that are
046     * available for use in Directory Server plugins.  This is a single
047     * class that may be used for all types of plugins, and an individual
048     * plugin only needs to implement the specific methods that are
049     * applicable to that particular plugin type.
050     *
051     * @param  <T>  The type of configuration handled by this plugin.
052     */
053    @org.opends.server.types.PublicAPI(
054         stability=org.opends.server.types.StabilityLevel.UNCOMMITTED,
055         mayInstantiate=false,
056         mayExtend=true,
057         mayInvoke=false)
058    public abstract class DirectoryServerPlugin
059           <T extends PluginCfg>
060    {
061      // Indicates whether this plugin should be invoked for internal
062      // operations.
063      private boolean invokeForInternalOps;
064    
065      // The DN of the configuration entry for this plugin.
066      private DN pluginDN;
067    
068      // The plugin types for which this plugin is registered.
069      private Set<PluginType> pluginTypes;
070    
071    
072    
073      /**
074       * Creates a new instance of this Directory Server plugin.  Every
075       * plugin must implement a default constructor (it is the only one
076       * that will be used to create plugins defined in the
077       * configuration), and every plugin constructor must call
078       * {@code super()} as its first action.
079       */
080      protected DirectoryServerPlugin()
081      {
082      }
083    
084    
085    
086      /**
087       * Indicates whether the provided configuration is acceptable for
088       * this plugin.  It should be possible to call this method on an
089       * uninitialized plugin instance in order to determine whether the
090       * plugin would be able to use the provided configuration.
091       *
092       * @param  configuration        The plugin configuration for which
093       *                              to make the determination.
094       * @param  unacceptableReasons  A list that may be used to hold the
095       *                              reasons that the provided
096       *                              configuration is not acceptable.
097       *
098       * @return  {@code true} if the provided configuration is acceptable
099       *          for this plugin, or {@code false} if not.
100       */
101      public boolean isConfigurationAcceptable(PluginCfg configuration,
102                          List<Message> unacceptableReasons)
103      {
104        // This default implementation does not perform any special
105        // validation.  It should be overridden by plugin implementations
106        // that wish to perform more detailed validation.
107        return true;
108      }
109    
110    
111    
112      /**
113       * Performs any initialization that should be done for all types of
114       * plugins regardless of type.  This should only be called by the
115       * core Directory Server code during the course of loading a plugin.
116       *
117       * @param  configuration  The configuration for this plugin.
118       * @param  pluginTypes    The set of plugin types for which this
119       *                        plugin is registered.
120       */
121      @org.opends.server.types.PublicAPI(
122           stability=org.opends.server.types.StabilityLevel.PRIVATE,
123           mayInstantiate=false,
124           mayExtend=false,
125           mayInvoke=false)
126      public final void initializeInternal(PluginCfg configuration,
127                                           Set<PluginType> pluginTypes)
128      {
129        this.pluginTypes = pluginTypes;
130    
131        pluginDN = configuration.dn();
132        invokeForInternalOps =
133             configuration.isInvokeForInternalOperations();
134      }
135    
136    
137    
138      /**
139       * Performs any initialization necessary for this plugin.  This will
140       * be called as soon as the plugin has been loaded and before it is
141       * registered with the server.
142       *
143       * @param  pluginTypes    The set of plugin types that indicate the
144       *                        ways in which this plugin will be invoked.
145       * @param  configuration  The configuration for this plugin.
146       *
147       * @throws  ConfigException  If the provided entry does not contain
148       *                           a valid configuration for this plugin.
149       *
150       * @throws  InitializationException  If a problem occurs while
151       *                                   initializing the plugin that is
152       *                                   not related to the server
153       *                                   configuration.
154       */
155      public abstract void initializePlugin(Set<PluginType> pluginTypes,
156                                            T configuration)
157             throws ConfigException, InitializationException;
158    
159    
160    
161      /**
162       * Performs any necessary finalization for this plugin.  This will
163       * be called just after the plugin has been deregistered with the
164       * server but before it has been unloaded.
165       */
166      public void finalizePlugin()
167      {
168        // No implementation is required by default.
169      }
170    
171    
172    
173      /**
174       * Retrieves the DN of the configuration entry for this plugin.
175       *
176       * @return  The DN of the configuration entry for this plugin.
177       */
178      public final DN getPluginEntryDN()
179      {
180        return pluginDN;
181      }
182    
183    
184    
185      /**
186       * Retrieves the plugin types for which this plugin is registered.
187       * This set must not be modified.
188       *
189       * @return  The plugin types for which this plugin is registered.
190       */
191      public final Set<PluginType> getPluginTypes()
192      {
193        return pluginTypes;
194      }
195    
196    
197    
198      /**
199       * Indicates whether this plugin should be invoked for internal
200       * operations.
201       *
202       * @return  {@code true} if this plugin should be invoked for
203       *          internal operations, or {@code false} if not.
204       */
205      public final boolean invokeForInternalOperations()
206      {
207        return invokeForInternalOps;
208      }
209    
210    
211    
212      /**
213       * Specifies whether this plugin should be invoked for internal
214       * operations.
215       *
216       * @param  invokeForInternalOps  Indicates whether this plugin
217       *                               should be invoked for internal
218       *                               operations.
219       */
220      @org.opends.server.types.PublicAPI(
221           stability=org.opends.server.types.StabilityLevel.PRIVATE,
222           mayInstantiate=false,
223           mayExtend=false,
224           mayInvoke=false)
225      public final void setInvokeForInternalOperations(
226                             boolean invokeForInternalOps)
227      {
228        this.invokeForInternalOps = invokeForInternalOps;
229      }
230    
231    
232    
233      /**
234       * Performs any processing that should be done when the Directory
235       * Server is in the process of starting.  This method will be called
236       * after virtually all other initialization has been performed but
237       * before the connection handlers are started.
238       *
239       * @return  The result of the startup plugin processing.
240       */
241      public PluginResult.Startup doStartup()
242      {
243        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
244            String.valueOf(pluginDN), PluginType.STARTUP.getName());
245        throw new UnsupportedOperationException(message.toString());
246      }
247    
248    
249    
250      /**
251       * Performs any processing that should be done when the Directory
252       * Server is in the process of performing a graceful shutdown.  This
253       * method will be called early in the shutdown process after the
254       * connection handlers are stopped but before other finalization is
255       * performed.
256       *
257       * @param  reason  The human-readable reason for the shutdown.
258       */
259      public void doShutdown(Message reason)
260      {
261        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
262            String.valueOf(pluginDN), PluginType.SHUTDOWN.getName());
263        throw new UnsupportedOperationException(message.toString());
264      }
265    
266    
267    
268      /**
269       * Performs any processing that should be done when the Directory
270       * Server accepts a new connection from a client.  This method will
271       * be called after additional verification is performed to ensure
272       * that the connection should be accepted.
273       *
274       * @param  clientConnection  The client connection that has been
275       *                           accepted.
276       *
277       * @return  The result of the plugin processing.
278       */
279      public PluginResult.PostConnect doPostConnect(ClientConnection
280                                                        clientConnection)
281      {
282        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
283            String.valueOf(pluginDN), PluginType.POST_CONNECT.getName());
284        throw new UnsupportedOperationException(message.toString());
285      }
286    
287    
288    
289      /**
290       * Performs any processing that should be done whenever a client
291       * connection is closed (regardless of whether the closure is
292       * initiated by the client or the server).
293       *
294       * @param  clientConnection  The client connection that has been
295       *                           closed.
296       * @param  disconnectReason  The disconnect reason for the closure.
297       * @param  message           A message providing additional
298       *                           information about the closure, or
299       *                           {@code null} if there is none.
300       *
301       * @return  The result of the plugin processing.
302       */
303      public PluginResult.PostDisconnect
304                  doPostDisconnect(ClientConnection clientConnection,
305                                   DisconnectReason disconnectReason,
306                                   Message message)
307      {
308        Message msg = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
309            get(String.valueOf(pluginDN),
310                PluginType.POST_DISCONNECT.getName());
311        throw new UnsupportedOperationException(msg.toString());
312      }
313    
314    
315    
316      /**
317       * Performs any necessary processing that should be done during an
318       * LDIF import operation immediately after reading an entry and
319       * confirming that it should be imported based on the provided
320       * configuration.
321       *
322       * @param  importConfig  The configuration used for the LDIF import.
323       * @param  entry         The entry that has been read to the LDIF
324       *                       file.
325       *
326       * @return  The result of the plugin processing.
327       */
328      public PluginResult.ImportLDIF
329        doLDIFImport(LDIFImportConfig importConfig, Entry entry)
330      {
331        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
332            String.valueOf(pluginDN), PluginType.LDIF_IMPORT.getName());
333        throw new UnsupportedOperationException(message.toString());
334      }
335    
336    
337    
338      /**
339       * Performs any necessary processing that should be done during an
340       * LDIF export operation immediately after determining that the
341       * provided entry should be included in the export.
342       *
343       * @param  exportConfig  The configuration used for the LDIF export.
344       * @param  entry         The entry to be written to the LDIF file.
345       *
346       * @return  The result of the plugin processing.
347       */
348      public PluginResult.ImportLDIF
349        doLDIFExport(LDIFExportConfig exportConfig, Entry entry)
350      {
351        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
352            String.valueOf(pluginDN), PluginType.LDIF_EXPORT.getName());
353        throw new UnsupportedOperationException(message.toString());
354      }
355    
356    
357    
358      /**
359       * Performs any necessary processing that should be done before the
360       * Directory Server parses the elements of an abandon request.
361       *
362       * @param  abandonOperation  The abandon operation that has been
363       *                           requested.
364       *
365       * @return  Information about the result of the plugin processing.
366       */
367      public PluginResult.PreParse
368           doPreParse(PreParseAbandonOperation abandonOperation)
369      {
370        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
371            get(String.valueOf(pluginDN),
372                PluginType.PRE_PARSE_ABANDON.getName());
373        throw new UnsupportedOperationException(message.toString());
374      }
375    
376    
377    
378      /**
379       * Performs any necessary processing that should be done after the
380       * Directory Server has completed processing for an abandon
381       * operation.
382       *
383       * @param  abandonOperation  The abandon operation for which
384       *                           processing has completed.
385       *
386       * @return  Information about the result of the plugin processing.
387       */
388      public PluginResult.PostOperation
389           doPostOperation(PostOperationAbandonOperation abandonOperation)
390      {
391        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
392            get(String.valueOf(pluginDN),
393                PluginType.POST_OPERATION_ABANDON.getName());
394        throw new UnsupportedOperationException(message.toString());
395      }
396    
397    
398    
399      /**
400       * Performs any necessary processing that should be done before the
401       * Directory Server parses the elements of an add request.
402       *
403       * @param  addOperation  The add operation that has been requested.
404       *
405       * @return  Information about the result of the plugin processing.
406       *
407       * @throws CanceledOperationException if this operation should
408       * be cancelled.
409       */
410      public PluginResult.PreParse
411           doPreParse(PreParseAddOperation addOperation)
412           throws CanceledOperationException {
413        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
414            String.valueOf(pluginDN), PluginType.PRE_PARSE_ADD.getName());
415        throw new UnsupportedOperationException(message.toString());
416      }
417    
418    
419    
420      /**
421       * Performs any necessary processing that should be done just before
422       * the Directory Server performs the core processing for an add
423       * operation.
424       * This method is not called when processing synchronization
425       * operations.
426       *
427       * @param  addOperation  The add operation to be processed.
428       *
429       * @return  Information about the result of the plugin processing.
430       *
431       * @throws CanceledOperationException if this operation should
432       * be cancelled.
433       */
434      public PluginResult.PreOperation
435           doPreOperation(PreOperationAddOperation addOperation)
436          throws CanceledOperationException {
437        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
438            get(String.valueOf(pluginDN),
439                PluginType.PRE_OPERATION_ADD.getName());
440        throw new UnsupportedOperationException(message.toString());
441      }
442    
443    
444    
445      /**
446       * Performs any necessary processing that should be done after the
447       * Directory Server has completed the core processing for an add
448       * operation but before the response has been sent to the client.
449       *
450       * @param  addOperation  The add operation for which processing has
451       *                       completed but no response has yet been
452       *                       sent.
453       *
454       * @return  Information about the result of the plugin processing.
455       */
456      public PluginResult.PostOperation
457           doPostOperation(PostOperationAddOperation addOperation)
458      {
459        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
460            get(String.valueOf(pluginDN),
461                PluginType.POST_OPERATION_ADD.getName());
462        throw new UnsupportedOperationException(message.toString());
463      }
464    
465    
466    
467      /**
468       * Performs any necessary processing that should be done after the
469       * Directory Server has completed all processing for an add
470       * operation and has sent the response to the client.
471       *
472       * @param  addOperation  The add operation for which processing has
473       *                       completed and the response has been sent to
474       *                       the client.
475       *
476       * @return  Information about the result of the plugin processing.
477       */
478      public PluginResult.PostResponse
479           doPostResponse(PostResponseAddOperation addOperation)
480      {
481        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
482            get(String.valueOf(pluginDN),
483                PluginType.POST_RESPONSE_ADD.getName());
484        throw new UnsupportedOperationException(message.toString());
485      }
486    
487    
488    
489      /**
490       * Performs any necessary processing that should be done after the
491       * Directory Server has completed processing for an add operation
492       * performed via synchronization.
493       *
494       * @param  addOperation  The synchronized add operation for which
495       *                       processing has been completed.
496       */
497      public void doPostSynchronization(
498                       PostSynchronizationAddOperation addOperation)
499      {
500        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
501            get(String.valueOf(pluginDN),
502                PluginType.POST_SYNCHRONIZATION_ADD.getName());
503        throw new UnsupportedOperationException(message.toString());
504      }
505    
506    
507    
508      /**
509       * Performs any necessary processing that should be done before the
510       * Directory Server parses the elements of a bind request.
511       *
512       * @param  bindOperation  The bind operation that has been
513       *                        requested.
514       *
515       * @return  Information about the result of the plugin processing.
516       */
517      public PluginResult.PreParse
518           doPreParse(PreParseBindOperation bindOperation)
519      {
520        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
521            get(String.valueOf(pluginDN),
522                PluginType.PRE_PARSE_BIND.getName());
523        throw new UnsupportedOperationException(message.toString());
524      }
525    
526    
527    
528      /**
529       * Performs any necessary processing that should be done just before
530       * the Directory Server performs the core processing for a bind
531       * operation.
532       *
533       * @param  bindOperation  The bind operation to be processed.
534       *
535       * @return  Information about the result of the plugin processing.
536       */
537      public PluginResult.PreOperation
538           doPreOperation(PreOperationBindOperation bindOperation)
539      {
540        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
541            get(String.valueOf(pluginDN),
542                PluginType.PRE_OPERATION_BIND.getName());
543        throw new UnsupportedOperationException(message.toString());
544      }
545    
546    
547    
548      /**
549       * Performs any necessary processing that should be done after the
550       * Directory Server has completed the core processing for a bind
551       * operation but before the response has been sent to the client.
552       *
553       * @param  bindOperation  The bind operation for which processing
554       *                        has completed but no response has yet been
555       *                        sent.
556       *
557       * @return  Information about the result of the plugin processing.
558       */
559      public PluginResult.PostOperation
560           doPostOperation(PostOperationBindOperation bindOperation)
561      {
562        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
563            get(String.valueOf(pluginDN),
564                PluginType.POST_OPERATION_BIND.getName());
565        throw new UnsupportedOperationException(message.toString());
566      }
567    
568    
569    
570      /**
571       * Performs any necessary processing that should be done after the
572       * Directory Server has completed all processing for a bind
573       * operation and has sent the response to the client.
574       *
575       * @param  bindOperation  The bind operation for which processing
576       *                        has completed and the response has been
577       *                        sent to the client.
578       *
579       * @return  Information about the result of the plugin processing.
580       */
581      public PluginResult.PostResponse
582           doPostResponse(PostResponseBindOperation bindOperation)
583      {
584        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
585            get(String.valueOf(pluginDN),
586                PluginType.POST_RESPONSE_BIND.getName());
587        throw new UnsupportedOperationException(message.toString());
588      }
589    
590    
591    
592      /**
593       * Performs any necessary processing that should be done before the
594       * Directory Server parses the elements of a compare request.
595       *
596       * @param  compareOperation  The compare operation that has been
597       *                           requested.
598       *
599       * @return  Information about the result of the plugin processing.
600       *
601       * @throws CanceledOperationException if this operation should
602       * be cancelled.
603       */
604      public PluginResult.PreParse
605           doPreParse(PreParseCompareOperation compareOperation)
606           throws CanceledOperationException {
607        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
608            get(String.valueOf(pluginDN),
609                PluginType.PRE_PARSE_COMPARE.getName());
610        throw new UnsupportedOperationException(message.toString());
611      }
612    
613    
614    
615      /**
616       * Performs any necessary processing that should be done just before
617       * the Directory Server performs the core processing for a compare
618       * operation.
619       *
620       * @param  compareOperation  The compare operation to be processed.
621       *
622       * @return  Information about the result of the plugin processing.
623       *
624       * @throws CanceledOperationException if this operation should
625       * be cancelled.
626       */
627      public PluginResult.PreOperation
628           doPreOperation(PreOperationCompareOperation compareOperation)
629          throws CanceledOperationException {
630        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
631            get(String.valueOf(pluginDN),
632                PluginType.PRE_OPERATION_COMPARE.getName());
633        throw new UnsupportedOperationException(message.toString());
634      }
635    
636    
637    
638      /**
639       * Performs any necessary processing that should be done after the
640       * Directory Server has completed the core processing for a compare
641       * operation but before the response has been sent to the client.
642       *
643       * @param  compareOperation  The compare operation for which
644       *                           processing has completed but no
645       *                           response has yet been sent.
646       *
647       * @return  Information about the result of the plugin processing.
648       */
649      public PluginResult.PostOperation
650           doPostOperation(PostOperationCompareOperation compareOperation)
651      {
652        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
653            get(String.valueOf(pluginDN),
654                PluginType.POST_OPERATION_COMPARE.getName());
655        throw new UnsupportedOperationException(message.toString());
656      }
657    
658    
659    
660      /**
661       * Performs any necessary processing that should be done after the
662       * Directory Server has completed all processing for a compare
663       * operation and has sent the response to the client.
664       *
665       * @param  compareOperation  The compare operation for which
666       *                           processing has completed and the
667       *                           response has been sent to the client.
668       *
669       * @return  Information about the result of the plugin processing.
670       */
671      public PluginResult.PostResponse
672           doPostResponse(PostResponseCompareOperation compareOperation)
673      {
674        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
675            get(String.valueOf(pluginDN),
676                PluginType.POST_RESPONSE_COMPARE.getName());
677        throw new UnsupportedOperationException(message.toString());
678      }
679    
680    
681    
682      /**
683       * Performs any necessary processing that should be done before the
684       * Directory Server parses the elements of a delete request.
685       *
686       * @param  deleteOperation  The delete operation that has been
687       *                          requested.
688       *
689       * @return  Information about the result of the plugin processing.
690       *
691       * @throws CanceledOperationException if this operation should
692       * be cancelled.
693       */
694      public PluginResult.PreParse
695           doPreParse(PreParseDeleteOperation deleteOperation)
696           throws CanceledOperationException {
697        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
698            get(String.valueOf(pluginDN),
699                PluginType.PRE_PARSE_DELETE.getName());
700        throw new UnsupportedOperationException(message.toString());
701      }
702    
703    
704    
705      /**
706       * Performs any necessary processing that should be done just before
707       * the Directory Server performs the core processing for a delete
708       * operation.
709       * This method is not called when processing synchronization
710       * operations.
711       *
712       * @param  deleteOperation  The delete operation to be processed.
713       *
714       * @return  Information about the result of the plugin processing.
715       *
716       * @throws CanceledOperationException if this operation should
717       * be cancelled.
718       */
719      public PluginResult.PreOperation
720           doPreOperation(PreOperationDeleteOperation deleteOperation)
721          throws CanceledOperationException {
722        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
723            get(String.valueOf(pluginDN),
724                PluginType.PRE_OPERATION_DELETE.getName());
725        throw new UnsupportedOperationException(message.toString());
726      }
727    
728    
729    
730      /**
731       * Performs any necessary processing that should be done after the
732       * Directory Server has completed the core processing for a delete
733       * operation but before the response has been sent to the client.
734       *
735       * @param  deleteOperation  The delete operation for which
736       *                          processing has completed but no
737       *                          response has yet been sent.
738       *
739       * @return  Information about the result of the plugin processing.
740       */
741      public PluginResult.PostOperation
742           doPostOperation(PostOperationDeleteOperation deleteOperation)
743      {
744        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
745            get(String.valueOf(pluginDN),
746                PluginType.POST_OPERATION_DELETE.getName());
747        throw new UnsupportedOperationException(message.toString());
748      }
749    
750    
751    
752      /**
753       * Performs any necessary processing that should be done after the
754       * Directory Server has completed all processing for a delete
755       * operation and has sent the response to the client.
756       *
757       * @param  deleteOperation  The delete operation for which
758       *                          processing has completed and the
759       *                          response has been sent to the client.
760       *
761       * @return  Information about the result of the plugin processing.
762       */
763      public PluginResult.PostResponse
764           doPostResponse(PostResponseDeleteOperation deleteOperation)
765      {
766        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
767            get(String.valueOf(pluginDN),
768                PluginType.POST_RESPONSE_DELETE.getName());
769        throw new UnsupportedOperationException(message.toString());
770      }
771    
772    
773    
774      /**
775       * Performs any necessary processing that should be done after the
776       * Directory Server has completed processing for a delete operation
777       * performed via synchronization.
778       *
779       * @param  deleteOperation  The synchronized delete operation for
780       *                          which processing has been completed.
781       */
782      public void doPostSynchronization(
783                       PostSynchronizationDeleteOperation deleteOperation)
784      {
785        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
786            get(String.valueOf(pluginDN),
787                PluginType.POST_SYNCHRONIZATION_DELETE.getName());
788        throw new UnsupportedOperationException(message.toString());
789      }
790    
791    
792    
793      /**
794       * Performs any necessary processing that should be done before the
795       * Directory Server parses the elements of an extended request.
796       *
797       * @param  extendedOperation  The extended operation that has been
798       *                            requested.
799       *
800       * @return  Information about the result of the plugin processing.
801       *
802       * @throws CanceledOperationException if this operation should
803       * be cancelled.
804       */
805      public PluginResult.PreParse
806           doPreParse(PreParseExtendedOperation extendedOperation)
807           throws CanceledOperationException {
808        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
809            get(String.valueOf(pluginDN),
810                PluginType.PRE_PARSE_EXTENDED.getName());
811        throw new UnsupportedOperationException(message.toString());
812      }
813    
814    
815    
816      /**
817       * Performs any necessary processing that should be done just before
818       * the Directory Server performs the core processing for an extended
819       * operation.
820       *
821       * @param  extendedOperation  The extended operation to be
822       *                            processed.
823       *
824       * @return  Information about the result of the plugin processing.
825       *
826       * @throws CanceledOperationException if this operation should
827       * be cancelled.
828       */
829      public PluginResult.PreOperation
830           doPreOperation(PreOperationExtendedOperation extendedOperation)
831          throws CanceledOperationException {
832        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
833            get(String.valueOf(pluginDN),
834                PluginType.PRE_OPERATION_EXTENDED.getName());
835        throw new UnsupportedOperationException(message.toString());
836      }
837    
838    
839    
840      /**
841       * Performs any necessary processing that should be done after the
842       * Directory Server has completed the core processing for an
843       * extended operation but before the response has been sent to the
844       * client.
845       *
846       * @param  extendedOperation  The extended operation for which
847       *                            processing has completed but no
848       *                            response has yet been sent.
849       *
850       * @return  Information about the result of the plugin processing.
851       */
852      public PluginResult.PostOperation
853           doPostOperation(PostOperationExtendedOperation
854                                extendedOperation)
855      {
856        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
857            get(String.valueOf(pluginDN),
858                PluginType.POST_OPERATION_EXTENDED.getName());
859        throw new UnsupportedOperationException(message.toString());
860      }
861    
862    
863    
864      /**
865       * Performs any necessary processing that should be done after the
866       * Directory Server has completed all processing for an extended
867       * operation and has sent the response to the client.
868       *
869       * @param  extendedOperation  The extended operation for which
870       *                            processing has completed and the
871       *                            response has been sent to the client.
872       *
873       * @return  Information about the result of the plugin processing.
874       */
875      public PluginResult.PostResponse
876           doPostResponse(PostResponseExtendedOperation extendedOperation)
877      {
878        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
879            get(String.valueOf(pluginDN),
880                PluginType.POST_RESPONSE_EXTENDED.getName());
881        throw new UnsupportedOperationException(message.toString());
882      }
883    
884    
885    
886      /**
887       * Performs any necessary processing that should be done before the
888       * Directory Server parses the elements of a modify request.
889       *
890       * @param  modifyOperation  The modify operation that has been
891       *                          requested.
892       *
893       * @return  Information about the result of the plugin processing.
894       *
895       * @throws CanceledOperationException if this operation should
896       * be cancelled.
897       */
898      public PluginResult.PreParse
899           doPreParse(PreParseModifyOperation modifyOperation)
900           throws CanceledOperationException {
901        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
902            get(String.valueOf(pluginDN),
903                PluginType.PRE_PARSE_MODIFY.getName());
904        throw new UnsupportedOperationException(message.toString());
905      }
906    
907    
908    
909      /**
910       * Performs any necessary processing that should be done just before
911       * the Directory Server performs the core processing for a modify
912       * operation.
913       *
914       * This method is not called when processing synchronization
915       * operations.
916       * @param  modifyOperation  The modify operation to be processed.
917       *
918       * @return  Information about the result of the plugin processing.
919       *
920       * @throws CanceledOperationException if this operation should
921       * be cancelled.
922       */
923      public PluginResult.PreOperation
924           doPreOperation(PreOperationModifyOperation modifyOperation)
925          throws CanceledOperationException {
926        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
927            get(String.valueOf(pluginDN),
928                PluginType.PRE_OPERATION_MODIFY.getName());
929        throw new UnsupportedOperationException(message.toString());
930      }
931    
932    
933    
934      /**
935       * Performs any necessary processing that should be done after the
936       * Directory Server has completed the core processing for a modify
937       * operation but before the response has been sent to the client.
938       *
939       * @param  modifyOperation  The modify operation for which
940       *                          processing has completed but no response
941       *                          has yet been sent.
942       *
943       * @return  Information about the result of the plugin processing.
944       */
945      public PluginResult.PostOperation
946           doPostOperation(PostOperationModifyOperation modifyOperation)
947      {
948        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
949            get(String.valueOf(pluginDN),
950                PluginType.POST_OPERATION_MODIFY.getName());
951        throw new UnsupportedOperationException(message.toString());
952      }
953    
954    
955    
956      /**
957       * Performs any necessary processing that should be done after the
958       * Directory Server has completed all processing for a modify
959       * operation and has sent the response to the client.
960       *
961       * @param  modifyOperation  The modify operation for which
962       *                          processing has completed and the
963       *                          response has been sent to the client.
964       *
965       * @return  Information about the result of the plugin processing.
966       */
967      public PluginResult.PostResponse
968           doPostResponse(PostResponseModifyOperation modifyOperation)
969      {
970        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
971            get(String.valueOf(pluginDN),
972                PluginType.POST_RESPONSE_MODIFY.getName());
973        throw new UnsupportedOperationException(message.toString());
974      }
975    
976    
977    
978      /**
979       * Performs any necessary processing that should be done after the
980       * Directory Server has completed processing for a modify operation
981       * performed via synchronization.
982       *
983       * @param  modifyOperation  The synchronized modify operation for
984       *                          which processing has been completed.
985       */
986      public void doPostSynchronization(
987                       PostSynchronizationModifyOperation modifyOperation)
988      {
989        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
990            get(String.valueOf(pluginDN),
991                PluginType.POST_SYNCHRONIZATION_MODIFY.getName());
992        throw new UnsupportedOperationException(message.toString());
993      }
994    
995    
996    
997      /**
998       * Performs any necessary processing that should be done before the
999       * Directory Server parses the elements of a modify DN request.
1000       *
1001       * @param  modifyDNOperation  The modify DN operation that has been
1002       *                            requested.
1003       *
1004       * @return  Information about the result of the plugin processing.
1005       *
1006       * @throws CanceledOperationException if this operation should
1007       * be cancelled.
1008       */
1009      public PluginResult.PreParse
1010           doPreParse(PreParseModifyDNOperation modifyDNOperation)
1011           throws CanceledOperationException {
1012        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1013            get(String.valueOf(pluginDN),
1014                PluginType.PRE_PARSE_MODIFY_DN.getName());
1015        throw new UnsupportedOperationException(message.toString());
1016      }
1017    
1018    
1019    
1020      /**
1021       * Performs any necessary processing that should be done just before
1022       * the Directory Server performs the core processing for a modify DN
1023       * operation.
1024       * This method is not called when processing synchronization
1025       * operations.
1026       *
1027       * @param  modifyDNOperation  The modify DN operation to be
1028       *                            processed.
1029       *
1030       * @return  Information about the result of the plugin processing.
1031       *
1032       * @throws CanceledOperationException if this operation should
1033       * be cancelled.
1034       */
1035      public PluginResult.PreOperation
1036           doPreOperation(PreOperationModifyDNOperation modifyDNOperation)
1037          throws CanceledOperationException {
1038        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1039            get(String.valueOf(pluginDN),
1040                PluginType.PRE_OPERATION_MODIFY_DN.getName());
1041        throw new UnsupportedOperationException(message.toString());
1042      }
1043    
1044    
1045    
1046      /**
1047       * Performs any necessary processing that should be done whenever a
1048       * subordinate entry is moved or renamed as part of a modify DN
1049       * operation.  Note that if the entry is to be changed in any way,
1050       * the new entry should be directly modified, and the changes made
1051       * should also be added to the provided list of modifications.
1052       * <BR><BR>
1053       * NOTE:  At the present time, OpenDS does not provide support for
1054       * altering entries subordinate to the target of a modify DN
1055       * operation.  While this may be available in the future, current
1056       * plugins should not attempt to alter the new or old entries in any
1057       * way, nor should they attempt to add any modifications to the
1058       * provided list.
1059       *
1060       * @param  modifyDNOperation  The modify DN operation with which the
1061       *                            subordinate entry is associated.
1062       * @param  oldEntry           The subordinate entry prior to the
1063       *                            move/rename operation.
1064       * @param  newEntry           The subordinate enry after the
1065       *                            move/rename operation.
1066       * @param  modifications      A list into which any modifications
1067       *                            made to the target entry should be
1068       *                            placed.
1069       *
1070       * @return  Information about the result of the plugin processing.
1071       */
1072      public PluginResult.SubordinateModifyDN
1073           processSubordinateModifyDN(SubordinateModifyDNOperation
1074                                           modifyDNOperation,
1075                                      Entry oldEntry, Entry newEntry,
1076                                      List<Modification> modifications)
1077      {
1078        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.get(
1079                String.valueOf(pluginDN),
1080                PluginType.SUBORDINATE_MODIFY_DN.getName());
1081        throw new UnsupportedOperationException(message.toString());
1082      }
1083    
1084    
1085    
1086      /**
1087       * Performs any necessary processing that should be done after the
1088       * Directory Server has completed the core processing for a modify
1089       * DN operation but before the response has been sent to the client.
1090       *
1091       * @param  modifyDNOperation  The modify DN operation for which
1092       *                            processing has completed but no
1093       *                            response has yet been sent.
1094       *
1095       * @return  Information about the result of the plugin processing.
1096       */
1097      public PluginResult.PostOperation
1098           doPostOperation(PostOperationModifyDNOperation
1099                                modifyDNOperation)
1100      {
1101        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1102            get(String.valueOf(pluginDN),
1103                PluginType.POST_OPERATION_MODIFY_DN.getName());
1104        throw new UnsupportedOperationException(message.toString());
1105      }
1106    
1107    
1108    
1109      /**
1110       * Performs any necessary processing that should be done after the
1111       * Directory Server has completed all processing for a modify DN
1112       * operation and has sent the response to the client.
1113       *
1114       * @param  modifyDNOperation  The modifyDN operation for which
1115       *                            processing has completed and the
1116       *                            response has been sent to the client.
1117       *
1118       * @return  Information about the result of the plugin processing.
1119       */
1120      public PluginResult.PostResponse
1121           doPostResponse(PostResponseModifyDNOperation modifyDNOperation)
1122      {
1123        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1124            get(String.valueOf(pluginDN),
1125                PluginType.POST_RESPONSE_MODIFY_DN.getName());
1126        throw new UnsupportedOperationException(message.toString());
1127      }
1128    
1129    
1130    
1131      /**
1132       * Performs any necessary processing that should be done after the
1133       * Directory Server has completed processing for a modify DN
1134       * operation performed via synchronization.
1135       *
1136       * @param  modifyDNOperation  The synchronized modify DN operation
1137       *                            for which processing has been
1138       *                            completed.
1139       */
1140      public void doPostSynchronization(
1141                  PostSynchronizationModifyDNOperation modifyDNOperation)
1142      {
1143        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1144            get(String.valueOf(pluginDN),
1145                PluginType.POST_SYNCHRONIZATION_MODIFY_DN.getName());
1146        throw new UnsupportedOperationException(message.toString());
1147      }
1148    
1149    
1150    
1151      /**
1152       * Performs any necessary processing that should be done before the
1153       * Directory Server parses the elements of a search request.
1154       *
1155       * @param  searchOperation  The search operation that has been
1156       *                          requested.
1157       *
1158       * @return  Information about the result of the plugin processing.
1159       *
1160       * @throws CanceledOperationException if this operation should
1161       * be cancelled.
1162       */
1163      public PluginResult.PreParse
1164           doPreParse(PreParseSearchOperation searchOperation)
1165           throws CanceledOperationException {
1166        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1167            get(String.valueOf(pluginDN),
1168                PluginType.PRE_PARSE_SEARCH.getName());
1169        throw new UnsupportedOperationException(message.toString());
1170      }
1171    
1172    
1173    
1174      /**
1175       * Performs any necessary processing that should be done just before
1176       * the Directory Server performs the core processing for a search
1177       * operation.
1178       *
1179       * @param  searchOperation  The search operation to be processed.
1180       *
1181       * @return  Information about the result of the plugin processing.
1182       *
1183       * @throws CanceledOperationException if this operation should
1184       * be cancelled.
1185       */
1186      public PluginResult.PreOperation
1187           doPreOperation(PreOperationSearchOperation searchOperation)
1188          throws CanceledOperationException {
1189        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1190            get(String.valueOf(pluginDN),
1191                PluginType.PRE_OPERATION_SEARCH.getName());
1192        throw new UnsupportedOperationException(message.toString());
1193      }
1194    
1195    
1196    
1197      /**
1198       * Performs any necessary processing that should be done before a
1199       * search result entry is sent to a client.  This will be called
1200       * after it has been verified that the entry does actually match the
1201       * search criteria and after access control has been enforced to
1202       * ensure that the entry should be sent and/or to strip out
1203       * attributes/values that the user should not see.
1204       *
1205       * @param  searchOperation  The search operation with which the
1206       *                          search entry is associated.
1207       * @param  searchEntry      The search result entry that is to be
1208       *                          sent to the client.  Its contents may be
1209       *                          altered by the plugin if necessary.
1210       *
1211       * @return  Information about the result of the plugin processing.
1212       */
1213      public PluginResult.IntermediateResponse
1214           processSearchEntry(SearchEntrySearchOperation searchOperation,
1215                              SearchResultEntry searchEntry)
1216      {
1217        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1218            get(String.valueOf(pluginDN),
1219                PluginType.SEARCH_RESULT_ENTRY.getName());
1220        throw new UnsupportedOperationException(message.toString());
1221      }
1222    
1223    
1224    
1225      /**
1226       * Performs any necessary processing that should be done before a
1227       * search result reference is sent to a client.
1228       *
1229       * @param  searchOperation  The search operation with which the
1230       *                          search result reference is associated.
1231       * @param  searchReference  The search result reference that is to
1232       *                          be sent to the client.  Its contents may
1233       *                          be altered by the plugin if necessary.
1234       *
1235       * @return  Information about the result of the plugin processing.
1236       */
1237      public PluginResult.IntermediateResponse
1238           processSearchReference(SearchReferenceSearchOperation
1239                                       searchOperation,
1240                                  SearchResultReference searchReference)
1241      {
1242        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1243            get(String.valueOf(pluginDN),
1244                PluginType.SEARCH_RESULT_REFERENCE.getName());
1245        throw new UnsupportedOperationException(message.toString());
1246      }
1247    
1248    
1249    
1250      /**
1251       * Performs any necessary processing that should be done after the
1252       * Directory Server has completed the core processing for a search
1253       * operation but before the response has been sent to the client.
1254       *
1255       * @param  searchOperation  The search operation for which
1256       *                          processing has completed but no response
1257       *                          has yet been sent.
1258       *
1259       * @return  Information about the result of the plugin processing.
1260       */
1261      public PluginResult.PostOperation
1262           doPostOperation(PostOperationSearchOperation searchOperation)
1263      {
1264        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1265            get(String.valueOf(pluginDN),
1266                PluginType.POST_OPERATION_SEARCH.getName());
1267        throw new UnsupportedOperationException(message.toString());
1268      }
1269    
1270    
1271    
1272      /**
1273       * Performs any necessary processing that should be done after the
1274       * Directory Server has completed all processing for a search
1275       * operation and has sent the response to the client.
1276       *
1277       * @param  searchOperation  The search operation for which
1278       *                          processing has completed and the
1279       *                          response has been sent to the client.
1280       *
1281       * @return  Information about the result of the plugin processing.
1282       */
1283      public PluginResult.PostResponse
1284           doPostResponse(PostResponseSearchOperation searchOperation)
1285      {
1286        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1287            get(String.valueOf(pluginDN),
1288                PluginType.POST_RESPONSE_SEARCH.getName());
1289        throw new UnsupportedOperationException(message.toString());
1290      }
1291    
1292    
1293    
1294      /**
1295       * Performs any necessary processing that should be done before the
1296       * Directory Server parses the elements of an unbind request.
1297       *
1298       * @param  unbindOperation  The unbind operation that has been
1299       *                          requested.
1300       *
1301       * @return  Information about the result of the plugin processing.
1302       */
1303      public PluginResult.PreParse
1304           doPreParse(PreParseUnbindOperation unbindOperation)
1305      {
1306        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1307            get(String.valueOf(pluginDN),
1308                PluginType.PRE_PARSE_UNBIND.getName());
1309        throw new UnsupportedOperationException(message.toString());
1310      }
1311    
1312    
1313    
1314      /**
1315       * Performs any necessary processing that should be done after the
1316       * Directory Server has completed processing for an unbind
1317       * operation.
1318       *
1319       * @param  unbindOperation  The unbind operation for which
1320       *                          processing has completed.
1321       *
1322       * @return  Information about the result of the plugin processing.
1323       */
1324      public PluginResult.PostOperation
1325           doPostOperation(PostOperationUnbindOperation unbindOperation)
1326      {
1327        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1328            get(String.valueOf(pluginDN),
1329                PluginType.POST_OPERATION_UNBIND.getName());
1330        throw new UnsupportedOperationException(message.toString());
1331      }
1332    
1333    
1334    
1335      /**
1336       * Performs any necessary processing that should be done before an
1337       * intermediate response message is sent to a client.
1338       *
1339       * @param  intermediateResponse  The intermediate response to be
1340       *                               sent to the client.
1341       *
1342       * @return  Information about the result of the plugin processing.
1343       */
1344      public PluginResult.IntermediateResponse
1345                  processIntermediateResponse(
1346                       IntermediateResponse intermediateResponse)
1347      {
1348        Message message = ERR_PLUGIN_TYPE_NOT_SUPPORTED.
1349            get(String.valueOf(pluginDN),
1350                PluginType.INTERMEDIATE_RESPONSE.getName());
1351        throw new UnsupportedOperationException(message.toString());
1352      }
1353    }
1354