001/*
002 * Copyright 2014 UnboundID Corp.
003 * All Rights Reserved.
004 */
005/*
006 * Copyright (C) 2014 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 */
021package com.unboundid.ldap.listener.interceptor;
022
023
024
025import com.unboundid.ldap.sdk.LDAPException;
026
027import com.unboundid.util.Extensible;
028import com.unboundid.util.ThreadSafety;
029import com.unboundid.util.ThreadSafetyLevel;
030
031
032
033/**
034 * This class defines an API that may be used to intercept and potentially alter
035 * communication between an LDAP client and the in-memory directory server.  An
036 * operation interceptor may be enabled for use with the in-memory directory
037 * server by registering it with the
038 * {@link com.unboundid.ldap.listener.InMemoryDirectoryServerConfig}.  The
039 * default implementation of all methods defined in this class is to return the
040 * provided request or result without altering it in any way.
041 * <BR><BR>
042 * Note that any operation interceptors configured for use will be invoked only
043 * for requests received via LDAP.  Operations processed via method calls made
044 * directly to the {@link com.unboundid.ldap.listener.InMemoryDirectoryServer}
045 * class via the {@link com.unboundid.ldap.sdk.LDAPInterface} interface will not
046 * cause any operation interceptors to be invoked.
047 */
048@Extensible()
049@ThreadSafety(level=ThreadSafetyLevel.INTERFACE_THREADSAFE)
050public abstract class InMemoryOperationInterceptor
051{
052  /**
053   * Invokes any processing that should be performed for the provided add
054   * request before it is passed to the in-memory directory server.
055   *
056   * @param  request  Information about the request that was received from the
057   *                  client.
058   *
059   * @throws  LDAPException  If the provided operation should not be passed onto
060   *                         the in-memory directory server, but the result
061   *                         represented by this exception should be used
062   *                         instead.
063   */
064  public void processAddRequest(final InMemoryInterceptedAddRequest request)
065         throws LDAPException
066  {
067    // No processing will be performed by default.
068  }
069
070
071
072  /**
073   * Invokes any processing that should be performed for the provided add result
074   * before it is returned to the client.
075   *
076   * @param  result  Information about the add result that is to be returned to
077   *                 the client.
078   */
079  public void processAddResult(final InMemoryInterceptedAddResult result)
080  {
081    // No processing will be performed by default.
082  }
083
084
085
086  /**
087   * Invokes any processing that should be performed for the provided simple
088   * bind request before it is passed to the in-memory directory server.
089   *
090   * @param  request  Information about the request that was received from the
091   *                  client.
092   *
093   * @throws  LDAPException  If the provided operation should not be passed onto
094   *                         the in-memory directory server, but the result
095   *                         represented by this exception should be used
096   *                         instead.
097   */
098  public void processSimpleBindRequest(
099                   final InMemoryInterceptedSimpleBindRequest request)
100         throws LDAPException
101  {
102    // No processing will be performed by default.
103  }
104
105
106
107  /**
108   * Invokes any processing that should be performed for the provided simple
109   * bind result before it is returned to the client.
110   *
111   * @param  result  Information about the bind result that is to be returned to
112   *                 the client.
113   */
114  public void processSimpleBindResult(
115                   final InMemoryInterceptedSimpleBindResult result)
116  {
117    // No processing will be performed by default.
118  }
119
120
121
122  /**
123   * Invokes any processing that should be performed for the provided SASL bind
124   * request before it is passed to the in-memory directory server.
125   *
126   * @param  request  Information about the request that was received from the
127   *                  client.
128   *
129   * @throws  LDAPException  If the provided operation should not be passed onto
130   *                         the in-memory directory server, but the result
131   *                         represented by this exception should be used
132   *                         instead.
133   */
134  public void processSASLBindRequest(
135                   final InMemoryInterceptedSASLBindRequest request)
136         throws LDAPException
137  {
138    // No processing will be performed by default.
139  }
140
141
142
143  /**
144   * Invokes any processing that should be performed for the provided SASL bind
145   * result before it is returned to the client.
146   *
147   * @param  result  Information about the bind result that is to be returned to
148   *                 the client.
149   */
150  public void processSASLBindResult(
151                   final InMemoryInterceptedSASLBindResult result)
152  {
153    // No processing will be performed by default.
154  }
155
156
157
158  /**
159   * Invokes any processing that should be performed for the provided compare
160   * request before it is passed to the in-memory directory server.
161   *
162   * @param  request  Information about the request that was received from the
163   *                  client.
164   *
165   * @throws  LDAPException  If the provided operation should not be passed onto
166   *                         the in-memory directory server, but the result
167   *                         represented by this exception should be used
168   *                         instead.
169   */
170  public void processCompareRequest(
171                   final InMemoryInterceptedCompareRequest request)
172         throws LDAPException
173  {
174    // No processing will be performed by default.
175  }
176
177
178
179  /**
180   * Invokes any processing that should be performed for the provided compare
181   * result before it is returned to the client.
182   *
183   * @param  result  Information about the compare result that is to be returned
184   *                 to the client.
185   */
186  public void processCompareResult(
187                   final InMemoryInterceptedCompareResult result)
188  {
189    // No processing will be performed by default.
190  }
191
192
193
194  /**
195   * Invokes any processing that should be performed for the provided delete
196   * request before it is passed to the in-memory directory server.
197   *
198   * @param  request  Information about the request that was received from the
199   *                  client.
200   *
201   * @throws  LDAPException  If the provided operation should not be passed onto
202   *                         the in-memory directory server, but the result
203   *                         represented by this exception should be used
204   *                         instead.
205   */
206  public void processDeleteRequest(
207                   final InMemoryInterceptedDeleteRequest request)
208         throws LDAPException
209  {
210    // No processing will be performed by default.
211  }
212
213
214
215  /**
216   * Invokes any processing that should be performed for the provided delete
217   * result before it is returned to the client.
218   *
219   * @param  result  Information about the delete result that is to be returned
220   *                 to the client.
221   */
222  public void processDeleteResult(final InMemoryInterceptedDeleteResult result)
223  {
224    // No processing will be performed by default.
225  }
226
227
228
229  /**
230   * Invokes any processing that should be performed for the provided extended
231   * request before it is passed to the in-memory directory server.
232   *
233   * @param  request  Information about the request that was received from the
234   *                  client.
235   *
236   * @throws  LDAPException  If the provided operation should not be passed onto
237   *                         the in-memory directory server, but the result
238   *                         represented by this exception should be used
239   *                         instead.
240   */
241  public void processExtendedRequest(
242                   final InMemoryInterceptedExtendedRequest request)
243         throws LDAPException
244  {
245    // No processing will be performed by default.
246  }
247
248
249
250  /**
251   * Invokes any processing that should be performed for the provided extended
252   * result before it is returned to the client.
253   *
254   * @param  result  Information about the extended result that is to be
255   *                 returned to the client.
256   */
257  public void processExtendedResult(
258                   final InMemoryInterceptedExtendedResult result)
259  {
260    // No processing will be performed by default.
261  }
262
263
264
265  /**
266   * Invokes any processing that should be performed for the provided modify
267   * request before it is passed to the in-memory directory server.
268   *
269   * @param  request  Information about the request that was received from the
270   *                  client.
271   *
272   * @throws  LDAPException  If the provided operation should not be passed onto
273   *                         the in-memory directory server, but the result
274   *                         represented by this exception should be used
275   *                         instead.
276   */
277  public void processModifyRequest(
278                   final InMemoryInterceptedModifyRequest request)
279         throws LDAPException
280  {
281    // No processing will be performed by default.
282  }
283
284
285
286  /**
287   * Invokes any processing that should be performed for the provided modify
288   * result before it is returned to the client.
289   *
290   * @param  result  Information about the modify result that is to be returned
291   *                 to the client.
292   */
293  public void processModifyResult(final InMemoryInterceptedModifyResult result)
294  {
295    // No processing will be performed by default.
296  }
297
298
299
300  /**
301   * Invokes any processing that should be performed for the provided modify DN
302   * request before it is passed to the in-memory directory server.
303   *
304   * @param  request  Information about the request that was received from the
305   *                  client.
306   *
307   * @throws  LDAPException  If the provided operation should not be passed onto
308   *                         the in-memory directory server, but the result
309   *                         represented by this exception should be used
310   *                         instead.
311   */
312  public void processModifyDNRequest(
313                   final InMemoryInterceptedModifyDNRequest request)
314         throws LDAPException
315  {
316    // No processing will be performed by default.
317  }
318
319
320
321  /**
322   * Invokes any processing that should be performed for the provided modify DN
323   * result before it is returned to the client.
324   *
325   * @param  result  Information about the modify DN result that is to be
326   *                 returned to the client.
327   */
328  public void processModifyDNResult(
329                   final InMemoryInterceptedModifyDNResult result)
330  {
331    // No processing will be performed by default.
332  }
333
334
335
336  /**
337   * Invokes any processing that should be performed for the provided search
338   * request before it is passed to the in-memory directory server.
339   *
340   * @param  request  Information about the request that was received from the
341   *                  client.
342   *
343   * @throws  LDAPException  If the provided operation should not be passed onto
344   *                         the in-memory directory server, but the result
345   *                         represented by this exception should be used
346   *                         instead.
347   */
348  public void processSearchRequest(
349                   final InMemoryInterceptedSearchRequest request)
350         throws LDAPException
351  {
352    // No processing will be performed by default.
353  }
354
355
356
357  /**
358   * Invokes any processing that should be performed for the provided search
359   * result entry before it is returned to the client.
360   *
361   * @param  entry  Information about the search result entry to be returned
362   */
363  public void processSearchEntry(final InMemoryInterceptedSearchEntry entry)
364  {
365    // No processing will be performed by default.
366  }
367
368
369
370  /**
371   * Invokes any processing that should be performed for the provided search
372   * result reference before it is returned to the client.
373   *
374   * @param  reference  Information about the search result reference to be
375   *                    returned
376   */
377  public void processSearchReference(
378                   final InMemoryInterceptedSearchReference reference)
379  {
380    // No processing will be performed by default.
381  }
382
383
384
385  /**
386   * Invokes any processing that should be performed for the provided search
387   * result before it is returned to the client.
388   *
389   * @param  result  Information about the search result that is to be returned
390   *                 to the client.
391   */
392  public void processSearchResult(final InMemoryInterceptedSearchResult result)
393  {
394    // No processing will be performed by default.
395  }
396
397
398
399  /**
400   * Invokes any processing that should be performed for the provided
401   * intermediate response before it is returned to the client.
402   *
403   * @param  response  Information about the intermediate response to be
404   *                   returned to the client.
405   */
406  public void processIntermediateResponse(
407                   final InMemoryInterceptedIntermediateResponse response)
408  {
409    // No processing will be performed by default.
410  }
411}