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
029 import org.opends.messages.Message;
030 import org.opends.server.types.ResultCode;
031 import org.opends.server.types.DN;
032 import org.opends.server.types.DisconnectReason;
033
034 import java.util.List;
035
036 /**
037 * This class defines a data structure that holds information about
038 * the result of processing by a plugin.
039 */
040 @org.opends.server.types.PublicAPI(
041 stability=org.opends.server.types.StabilityLevel.UNCOMMITTED,
042 mayInstantiate=true,
043 mayExtend=false,
044 mayInvoke=true)
045 public final class PluginResult
046 {
047 /**
048 * Defines a startup plugin result consisting of either continue
049 * skip further plugins, or stop startup with an error message.
050 */
051 public static final class Startup
052 {
053 // Whether to continue startup.
054 private final boolean continueProcessing;
055
056 // Whether to invoke the rest of the plugins.
057 private final boolean continuePluginProcessing;
058
059 // An message explaining why startup should stop.
060 private final Message errorMessage;
061
062 private static Startup DEFAULT_RESULT =
063 new Startup(true, true, null);
064
065 /**
066 * Construct a new startup plugin result.
067 *
068 * @param continueProcessing Whether to continue startup.
069 * @param continuePluginProcessing Whether to invoke the rest
070 * of the plugins.
071 * @param errorMessage An message explaining why startup should
072 * stop.
073 */
074 private Startup(boolean continueProcessing,
075 boolean continuePluginProcessing,
076 Message errorMessage)
077 {
078 this.continueProcessing = continueProcessing;
079 this.errorMessage = errorMessage;
080 this.continuePluginProcessing = continuePluginProcessing;
081 }
082
083 /**
084 * Defines a continue processing startup plugin result.
085 *
086 * @return a continue processing startup plugin result.
087 */
088 public static Startup continueStartup()
089 {
090 return DEFAULT_RESULT;
091 }
092
093 /**
094 * Defines a skip further plugin processing startup plugin result.
095 *
096 * @return a skip further plugin processing startup plugin
097 * result.
098 */
099 public static Startup skipFurtherPluginProcesssing()
100 {
101 return new Startup(true, false, null);
102 }
103
104 /**
105 * Defines a new stop processing startup plugin result.
106 *
107 * @param errorMessage An message explaining why processing
108 * should stop for the given entry.
109 *
110 * @return a new stop processing startup plugin result.
111 */
112 public static Startup stopStartup(Message errorMessage)
113 {
114 return new Startup(false, false, errorMessage);
115 }
116
117 /**
118 * Whether to continue startup.
119 *
120 * @return <code>true</code> if processing should continue
121 * or <code>false</code> otherwise.
122 */
123 public boolean continueProcessing()
124 {
125 return continueProcessing;
126 }
127
128 /**
129 * Whether to invoke the rest of the plugins.
130 *
131 * @return <code>true</code> if the rest of the plugins should
132 * be invoked for <code>false</code> to skip the rest of the
133 * plugins.
134 */
135 public boolean continuePluginProcessing()
136 {
137 return continuePluginProcessing;
138 }
139
140 /**
141 * Retrieves the error message if <code>continueProcessing</code>
142 * returned <code>false</code>.
143 *
144 * @return An error message explaining why processing should
145 * stop or <code>null</code> if none is provided.
146 */
147 public Message getErrorMessage()
148 {
149 return errorMessage;
150 }
151 }
152
153 /**
154 * Defines a pre parse plugin result for core server operation
155 * processing consisting of either continue, skip further
156 * plugins, or stop operation processing with a result code,
157 * matched DN, referral URLs, and error message.
158 */
159 public static final class PreParse
160 {
161 // Whether to continue operation processing.
162 private final boolean continueProcessing;
163
164 // Whether to invoke the rest of the plugins.
165 private final boolean continuePluginProcessing;
166
167 // An message explaining why processing should stop.
168 private final Message errorMessage;
169
170 // The matched DN for this result.
171 private final DN matchedDN;
172
173 // The set of referral URLs for this result.
174 private final List<String> referralURLs;
175
176 // The result code for this result.
177 private final ResultCode resultCode;
178
179 private static PreParse DEFAULT_RESULT =
180 new PreParse(true, true, null, null, null, null);
181
182 /**
183 * Construct a new pre parse plugin result.
184 *
185 * @param continueProcessing Whether to continue startup.
186 * @param continuePluginProcessing Whether to invoke the rest
187 * of the plugins.
188 * @param errorMessage An message explaining why processing
189 * should stop.
190 * @param resultCode The result code for this result.
191 * @param matchedDN The matched DN for this result.
192 * @param referralURLs The set of referral URLs for this result.
193 * stop.
194 */
195 private PreParse (boolean continueProcessing,
196 boolean continuePluginProcessing,
197 Message errorMessage,
198 ResultCode resultCode, DN matchedDN,
199 List<String> referralURLs)
200 {
201 this.continueProcessing = continueProcessing;
202 this.errorMessage = errorMessage;
203 this.continuePluginProcessing = continuePluginProcessing;
204 this.resultCode = resultCode;
205 this.matchedDN = matchedDN;
206 this.referralURLs = referralURLs;
207 }
208
209 /**
210 * Defines a continue processing pre parse plugin result.
211 *
212 * @return a continue processing pre parse plugin result.
213 */
214 public static PreParse continueOperationProcessing()
215 {
216 return DEFAULT_RESULT;
217 }
218
219 /**
220 * Defines a skip further plugin processing pre parse plugin
221 * result.
222 *
223 * @return a skip further plugin processing pre parse plugin
224 * result.
225 */
226 public static PreParse skipFurtherPluginProcesssing()
227 {
228 return new PreParse(true, false, null, null, null, null);
229 }
230
231 /**
232 * Defines a new stop processing pre parse plugin result.
233 *
234 * @param resultCode The result code for this result.
235 * @param errorMessage An message explaining why processing
236 * should stop.
237 * @param matchedDN The matched DN for this result.
238 * @param referralURLs The set of referral URLs for this result.
239 *
240 * @return a new stop processing pre parse plugin result.
241 */
242 public static PreParse stopProcessing(ResultCode resultCode,
243 Message errorMessage,
244 DN matchedDN,
245 List<String> referralURLs)
246 {
247 return new PreParse(false, false, errorMessage, resultCode,
248 matchedDN, referralURLs);
249 }
250
251 /**
252 * Contrust a new stop processing pre parse plugin result.
253 *
254 * @param resultCode The result code for this result.
255 * @param errorMessage An message explaining why processing
256 * should stop.
257 *
258 * @return a new stop processing pre parse plugin result.
259 */
260 public static PreParse stopProcessing(ResultCode resultCode,
261 Message errorMessage)
262 {
263 return new PreParse(false, false, errorMessage, resultCode,
264 null, null);
265 }
266
267 /**
268 * Whether to continue operation processing.
269 *
270 * @return <code>true</code> if processing should continue
271 * or <code>false</code> otherwise.
272 */
273 public boolean continueProcessing()
274 {
275 return continueProcessing;
276 }
277
278 /**
279 * Whether to invoke the rest of the plugins.
280 *
281 * @return <code>true</code> if the rest of the plugins should
282 * be invoked for <code>false</code> to skip the rest of the
283 * plugins.
284 */
285 public boolean continuePluginProcessing()
286 {
287 return continuePluginProcessing;
288 }
289
290 /**
291 * Retrieves the error message if <code>continueProcessing</code>
292 * returned <code>false</code>.
293 *
294 * @return An error message explaining why processing should
295 * stop or <code>null</code> if none is provided.
296 */
297 public Message getErrorMessage()
298 {
299 return errorMessage;
300 }
301
302 /**
303 * Retrieves the result code for the operation
304 * if <code>continueProcessing</code> returned <code>false</code>.
305 *
306 * @return the result code for the operation or <code>null</code>
307 * if none is provided.
308 */
309 public ResultCode getResultCode()
310 {
311 return resultCode;
312 }
313
314 /**
315 * Retrieves the matched DN for the operation
316 * if <code>continueProcessing</code> returned <code>false</code>.
317 *
318 * @return the matched DN for the operation or <code>null</code>
319 * if none is provided.
320 */
321 public DN getMatchedDN()
322 {
323 return matchedDN;
324 }
325
326 /**
327 * Retrieves the referral URLs for the operation
328 * if <code>continueProcessing</code> returned <code>false</code>.
329 *
330 * @return the refferal URLs for the operation or
331 * <code>null</code> if none is provided.
332 */
333 public List<String> getReferralURLs()
334 {
335 return referralURLs;
336 }
337 }
338
339 /**
340 * Defines a pre operation plugin result for core server operation
341 * processing consisting of either continue, skip further
342 * plugins, or stop operation processing with a result code,
343 * matched DN, referral URLs, and error message.
344 */
345 public static final class PreOperation
346 {
347 // Whether to continue operation processing.
348 private final boolean continueProcessing;
349
350 // Whether to invoke the rest of the plugins.
351 private final boolean continuePluginProcessing;
352
353 // An message explaining why processing should stop.
354 private final Message errorMessage;
355
356 // The matched DN for this result.
357 private final DN matchedDN;
358
359 // The set of referral URLs for this result.
360 private final List<String> referralURLs;
361
362 // The result code for this result.
363 private final ResultCode resultCode;
364
365 private static PreOperation DEFAULT_RESULT =
366 new PreOperation(true, true, null, null, null, null);
367
368 /**
369 * Construct a new pre operation plugin result.
370 *
371 * @param continueProcessing Whether to continue startup.
372 * @param continuePluginProcessing Whether to invoke the rest
373 * of the plugins.
374 * @param errorMessage An message explaining why processing
375 * should stop.
376 * @param resultCode The result code for this result.
377 * @param matchedDN The matched DN for this result.
378 * @param referralURLs The set of referral URLs for this result.
379 * stop.
380 */
381 private PreOperation (boolean continueProcessing,
382 boolean continuePluginProcessing,
383 Message errorMessage,
384 ResultCode resultCode, DN matchedDN,
385 List<String> referralURLs)
386 {
387 this.continueProcessing = continueProcessing;
388 this.errorMessage = errorMessage;
389 this.continuePluginProcessing = continuePluginProcessing;
390 this.resultCode = resultCode;
391 this.matchedDN = matchedDN;
392 this.referralURLs = referralURLs;
393 }
394
395 /**
396 * Defines a continue processing pre operation plugin result.
397 *
398 * @return a continue processing pre operation plugin result.
399 */
400 public static PreOperation continueOperationProcessing()
401 {
402 return DEFAULT_RESULT;
403 }
404
405 /**
406 * Defines a skip further plugin processing pre operation plugin
407 * result.
408 *
409 * @return a skip further plugin processing pre operation plugin
410 * result.
411 */
412 public static PreOperation skipFurtherPluginProcesssing()
413 {
414 return new PreOperation(true, false, null, null, null, null);
415 }
416
417 /**
418 * Defines a new stop processing pre operation plugin result.
419 *
420 * @param resultCode The result code for this result.
421 * @param errorMessage An message explaining why processing
422 * should stop.
423 * @param matchedDN The matched DN for this result.
424 * @param referralURLs The set of referral URLs for this result.
425 *
426 * @return a new stop processing pre operation plugin result.
427 */
428 public static PreOperation stopProcessing(
429 ResultCode resultCode, Message errorMessage, DN matchedDN,
430 List<String> referralURLs)
431 {
432 return new PreOperation(false, false, errorMessage, resultCode,
433 matchedDN, referralURLs);
434 }
435
436 /**
437 * Contrust a new stop processing pre operation plugin result.
438 *
439 * @param resultCode The result code for this result.
440 * @param errorMessage An message explaining why processing
441 * should stop.
442 *
443 * @return a new stop processing pre operation plugin result.
444 */
445 public static PreOperation stopProcessing(ResultCode resultCode,
446 Message errorMessage)
447 {
448 return new PreOperation(false, false, errorMessage, resultCode,
449 null, null);
450 }
451
452 /**
453 * Whether to continue operation processing.
454 *
455 * @return <code>true</code> if processing should continue
456 * or <code>false</code> otherwise.
457 */
458 public boolean continueProcessing()
459 {
460 return continueProcessing;
461 }
462
463 /**
464 * Whether to invoke the rest of the plugins.
465 *
466 * @return <code>true</code> if the rest of the plugins should
467 * be invoked for <code>false</code> to skip the rest of the
468 * plugins.
469 */
470 public boolean continuePluginProcessing()
471 {
472 return continuePluginProcessing;
473 }
474
475 /**
476 * Retrieves the error message if <code>continueProcessing</code>
477 * returned <code>false</code>.
478 *
479 * @return An error message explaining why processing should
480 * stop or <code>null</code> if none is provided.
481 */
482 public Message getErrorMessage()
483 {
484 return errorMessage;
485 }
486
487 /**
488 * Retrieves the result code for the operation
489 * if <code>continueProcessing</code> returned <code>false</code>.
490 *
491 * @return the result code for the operation or <code>null</code>
492 * if none is provided.
493 */
494 public ResultCode getResultCode()
495 {
496 return resultCode;
497 }
498
499 /**
500 * Retrieves the matched DN for the operation
501 * if <code>continueProcessing</code> returned <code>false</code>.
502 *
503 * @return the matched DN for the operation or <code>null</code>
504 * if none is provided.
505 */
506 public DN getMatchedDN()
507 {
508 return matchedDN;
509 }
510
511 /**
512 * Retrieves the referral URLs for the operation
513 * if <code>continueProcessing</code> returned <code>false</code>.
514 *
515 * @return the refferal URLs for the operation or
516 * <code>null</code> if none is provided.
517 */
518 public List<String> getReferralURLs()
519 {
520 return referralURLs;
521 }
522 }
523
524 /**
525 * Defines a post operation plugin result for core server operation
526 * processing consisting of either continue, skip further
527 * plugins, or stop operation processing with a result code,
528 * matched DN, referral URLs, and error message.
529 */
530 public static final class PostOperation
531 {
532 // Whether to continue operation processing.
533 private final boolean continueProcessing;
534
535 // An message explaining why processing should stop.
536 private final Message errorMessage;
537
538 // The matched DN for this result.
539 private final DN matchedDN;
540
541 // The set of referral URLs for this result.
542 private final List<String> referralURLs;
543
544 // The result code for this result.
545 private final ResultCode resultCode;
546
547 private static PostOperation DEFAULT_RESULT =
548 new PostOperation(true, null, null, null, null);
549
550 /**
551 * Constructs a new post operation plugin result.
552 *
553 * @param continueProcessing Whether to continue startup.
554 * @param errorMessage An message explaining why processing
555 * should stop.
556 * @param resultCode The result code for this result.
557 * @param matchedDN The matched DN for this result.
558 * @param referralURLs The set of referral URLs for this result.
559 */
560 private PostOperation(boolean continueProcessing,
561 Message errorMessage,
562 ResultCode resultCode, DN matchedDN,
563 List<String> referralURLs)
564 {
565 this.continueProcessing = continueProcessing;
566 this.errorMessage = errorMessage;
567 this.resultCode = resultCode;
568 this.matchedDN = matchedDN;
569 this.referralURLs = referralURLs;
570 }
571
572 /**
573 * Defines a continue processing post operation plugin result.
574 *
575 * @return a continue processing post operation plugin result.
576 */
577 public static PostOperation continueOperationProcessing()
578 {
579 return DEFAULT_RESULT;
580 }
581
582 /**
583 * Defines a new stop processing post operation plugin result.
584 *
585 * @param resultCode The result code for this result.
586 * @param errorMessage An message explaining why processing
587 * should stop.
588 * @param matchedDN The matched DN for this result.
589 * @param referralURLs The set of referral URLs for this result.
590 *
591 * @return a new stop processing post operation plugin result.
592 */
593 public static PostOperation stopProcessing(
594 ResultCode resultCode, Message errorMessage, DN matchedDN,
595 List<String> referralURLs)
596 {
597 return new PostOperation(false, errorMessage, resultCode,
598 matchedDN, referralURLs);
599 }
600
601 /**
602 * Contrust a new stop processing post operation plugin result.
603 *
604 * @param resultCode The result code for this result.
605 * @param errorMessage An message explaining why processing
606 * should stop.
607 *
608 * @return a new stop processing post operation plugin result.
609 */
610 public static PostOperation stopProcessing(ResultCode resultCode,
611 Message errorMessage)
612 {
613 return new PostOperation(false, errorMessage, resultCode, null,
614 null);
615 }
616
617 /**
618 * Whether to continue operation processing.
619 *
620 * @return <code>true</code> if processing should continue
621 * or <code>false</code> otherwise.
622 */
623 public boolean continueProcessing()
624 {
625 return continueProcessing;
626 }
627
628 /**
629 * Retrieves the error message if <code>continueProcessing</code>
630 * returned <code>false</code>.
631 *
632 * @return An error message explaining why processing should
633 * stop or <code>null</code> if none is provided.
634 */
635 public Message getErrorMessage()
636 {
637 return errorMessage;
638 }
639
640 /**
641 * Retrieves the result code for the operation
642 * if <code>continueProcessing</code> returned <code>false</code>.
643 *
644 * @return the result code for the operation or <code>null</code>
645 * if none is provided.
646 */
647 public ResultCode getResultCode()
648 {
649 return resultCode;
650 }
651
652 /**
653 * Retrieves the matched DN for the operation
654 * if <code>continueProcessing</code> returned <code>false</code>.
655 *
656 * @return the matched DN for the operation or <code>null</code>
657 * if none is provided.
658 */
659 public DN getMatchedDN()
660 {
661 return matchedDN;
662 }
663
664 /**
665 * Retrieves the referral URLs for the operation
666 * if <code>continueProcessing</code> returned <code>false</code>.
667 *
668 * @return the refferal URLs for the operation or
669 * <code>null</code> if none is provided.
670 */
671 public List<String> getReferralURLs()
672 {
673 return referralURLs;
674 }
675 }
676
677
678 /**
679 * Defines a post response plugin result for core server operation
680 * processing consisting of either continue or skip further
681 * plugins.
682 */
683 public static final class PostResponse
684 {
685 // Whether to invoke the rest of the plugins.
686 private final boolean continuePluginProcessing;
687
688 private static PostResponse DEFAULT_RESULT =
689 new PostResponse(true);
690
691 /**
692 * Constructs a new post response plugin result.
693 *
694 * @param continuePluginProcessing Whether to invoke the rest
695 * of the plugins.
696 */
697 private PostResponse (boolean continuePluginProcessing)
698 {
699 this.continuePluginProcessing = continuePluginProcessing;
700 }
701
702 /**
703 * Defines a continue processing post response plugin result.
704 *
705 * @return a continue processing post response plugin result.
706 */
707 public static PostResponse continueOperationProcessing()
708 {
709 return DEFAULT_RESULT;
710 }
711
712 /**
713 * Defines a skip further plugin processing post response plugin
714 * result.
715 *
716 * @return a skip further plugin processing post response plugin
717 * result.
718 */
719 public static PostResponse skipFurtherPluginProcesssing()
720 {
721 return new PostResponse(false);
722 }
723
724 /**
725 * Whether to invoke the rest of the plugins.
726 *
727 * @return <code>true</code> if the rest of the plugins should
728 * be invoked for <code>false</code> to skip the rest of the
729 * plugins.
730 */
731 public boolean continuePluginProcessing()
732 {
733 return continuePluginProcessing;
734 }
735 }
736
737 /**
738 * Defines a LDIF plugin result for import from LDIF
739 * processing consisting of either continue, skip further
740 * plugins, or stop processing with an error message.
741 */
742 public static final class ImportLDIF
743 {
744 // Whether to continue operation processing.
745 private final boolean continueProcessing;
746
747 // Whether to invoke the rest of the plugins.
748 private final boolean continuePluginProcessing;
749
750 // An message explaining why processing should stop.
751 private final Message errorMessage;
752
753 private static ImportLDIF DEFAULT_RESULT =
754 new ImportLDIF(true, true, null);
755
756 /**
757 * Construct a new import LDIF plugin result.
758 *
759 * @param continueProcessing Whether to continue startup.
760 * @param continuePluginProcessing Whether to invoke the rest
761 * of the plugins.
762 * @param errorMessage An message explaining why startup should
763 * stop.
764 */
765 private ImportLDIF(boolean continueProcessing,
766 boolean continuePluginProcessing,
767 Message errorMessage)
768 {
769 this.continueProcessing = continueProcessing;
770 this.errorMessage = errorMessage;
771 this.continuePluginProcessing = continuePluginProcessing;
772 }
773
774 /**
775 * Defines a continue processing LDIF import plugin result.
776 *
777 * @return a continue processing LDIF import plugin result.
778 */
779 public static ImportLDIF continueEntryProcessing()
780 {
781 return DEFAULT_RESULT;
782 }
783
784 /**
785 * Defines a skip further plugin processing LDIF import plugin
786 * result.
787 *
788 * @return a skip further plugin processing LDIF import plugin
789 * result.
790 */
791 public static ImportLDIF skipFurtherPluginProcesssing()
792 {
793 return new ImportLDIF(true, false, null);
794 }
795
796 /**
797 * Defines a new stop processing LDIF import plugin result.
798 *
799 * @param errorMessage An message explaining why processing
800 * should stop for the given entry.
801 *
802 * @return a new stop processing LDIF import plugin result.
803 */
804 public static ImportLDIF stopEntryProcessing(Message errorMessage)
805 {
806 return new ImportLDIF(false, false, errorMessage);
807 }
808
809 /**
810 * Whether to continue operation processing.
811 *
812 * @return <code>true</code> if processing should continue
813 * or <code>false</code> otherwise.
814 */
815 public boolean continueProcessing()
816 {
817 return continueProcessing;
818 }
819
820 /**
821 * Whether to invoke the rest of the plugins.
822 *
823 * @return <code>true</code> if the rest of the plugins should
824 * be invoked for <code>false</code> to skip the rest of the
825 * plugins.
826 */
827 public boolean continuePluginProcessing()
828 {
829 return continuePluginProcessing;
830 }
831
832 /**
833 * Retrieves the error message if <code>continueProcessing</code>
834 * returned <code>false</code>.
835 *
836 * @return An error message explaining why processing should
837 * stop or <code>null</code> if none is provided.
838 */
839 public Message getErrorMessage()
840 {
841 return errorMessage;
842 }
843 }
844
845 /**
846 * Defines a subordinate modify DN plugin result for core server
847 * operation processing consisting of either continue, skip further
848 * plugins, or stop operation processing with a result code,
849 * matched DN, referral URLs, and error message.
850 */
851 public static final class SubordinateModifyDN
852 {
853 // Whether to continue operation processing.
854 private final boolean continueProcessing;
855
856 // Whether to invoke the rest of the plugins.
857 private final boolean continuePluginProcessing;
858
859 // An message explaining why processing should stop.
860 private final Message errorMessage;
861
862 // The matched DN for this result.
863 private final DN matchedDN;
864
865 // The set of referral URLs for this result.
866 private final List<String> referralURLs;
867
868 // The result code for this result.
869 private final ResultCode resultCode;
870
871 private static SubordinateModifyDN DEFAULT_RESULT =
872 new SubordinateModifyDN(true, true, null, null, null, null);
873
874 /**
875 * Construct a new subordinate modify DN plugin result.
876 *
877 * @param continueProcessing Whether to continue startup.
878 * @param continuePluginProcessing Whether to invoke the rest
879 * of the plugins.
880 * @param errorMessage An message explaining why processing
881 * should stop.
882 * @param resultCode The result code for this result.
883 * @param matchedDN The matched DN for this result.
884 * @param referralURLs The set of referral URLs for this result.
885 * stop.
886 */
887 private SubordinateModifyDN(boolean continueProcessing,
888 boolean continuePluginProcessing,
889 Message errorMessage,
890 ResultCode resultCode, DN matchedDN,
891 List<String> referralURLs)
892 {
893 this.continueProcessing = continueProcessing;
894 this.errorMessage = errorMessage;
895 this.continuePluginProcessing = continuePluginProcessing;
896 this.resultCode = resultCode;
897 this.matchedDN = matchedDN;
898 this.referralURLs = referralURLs;
899 }
900
901 /**
902 * Defines a continue processing subordinate modify DN plugin
903 * result.
904 *
905 * @return a continue processing subordinate modify DN plugin
906 * result.
907 */
908 public static SubordinateModifyDN continueOperationProcessing()
909 {
910 return DEFAULT_RESULT;
911 }
912
913 /**
914 * Defines a skip further plugin processing subordinate modify DN
915 * plugin result.
916 *
917 * @return a skip further plugin processing subordinate modify DN
918 * plugin result.
919 */
920 public static SubordinateModifyDN skipFurtherPluginProcesssing()
921 {
922 return new SubordinateModifyDN(true, false, null, null, null,
923 null);
924 }
925
926 /**
927 * Defines a new stop processing subordinate modify DN plugin
928 * result.
929 *
930 * @param resultCode The result code for this result.
931 * @param errorMessage An message explaining why processing
932 * should stop.
933 * @param matchedDN The matched DN for this result.
934 * @param referralURLs The set of referral URLs for this result.
935 *
936 * @return a new stop processing subordinate modify DN plugin
937 * result.
938 */
939 public static SubordinateModifyDN stopProcessing(
940 ResultCode resultCode, Message errorMessage, DN matchedDN,
941 List<String> referralURLs)
942 {
943 return new SubordinateModifyDN(false, false, errorMessage,
944 resultCode, matchedDN, referralURLs);
945 }
946
947 /**
948 * Contrust a new stop processing subordinate modify DN plugin
949 * result.
950 *
951 * @param resultCode The result code for this result.
952 * @param errorMessage An message explaining why processing
953 * should stop.
954 *
955 * @return a new stop processing subordinate modify DN plugin
956 * result.
957 */
958 public static SubordinateModifyDN stopProcessing(
959 ResultCode resultCode, Message errorMessage)
960 {
961 return new SubordinateModifyDN(false, false, errorMessage,
962 resultCode, null, null);
963 }
964
965 /**
966 * Whether to continue operation processing.
967 *
968 * @return <code>true</code> if processing should continue
969 * or <code>false</code> otherwise.
970 */
971 public boolean continueProcessing()
972 {
973 return continueProcessing;
974 }
975
976 /**
977 * Whether to invoke the rest of the plugins.
978 *
979 * @return <code>true</code> if the rest of the plugins should
980 * be invoked for <code>false</code> to skip the rest of the
981 * plugins.
982 */
983 public boolean continuePluginProcessing()
984 {
985 return continuePluginProcessing;
986 }
987
988 /**
989 * Retrieves the error message if <code>continueProcessing</code>
990 * returned <code>false</code>.
991 *
992 * @return An error message explaining why processing should
993 * stop or <code>null</code> if none is provided.
994 */
995 public Message getErrorMessage()
996 {
997 return errorMessage;
998 }
999
1000 /**
1001 * Retrieves the result code for the operation
1002 * if <code>continueProcessing</code> returned <code>false</code>.
1003 *
1004 * @return the result code for the operation or <code>null</code>
1005 * if none is provided.
1006 */
1007 public ResultCode getResultCode()
1008 {
1009 return resultCode;
1010 }
1011
1012 /**
1013 * Retrieves the matched DN for the operation
1014 * if <code>continueProcessing</code> returned <code>false</code>.
1015 *
1016 * @return the matched DN for the operation or <code>null</code>
1017 * if none is provided.
1018 */
1019 public DN getMatchedDN()
1020 {
1021 return matchedDN;
1022 }
1023
1024 /**
1025 * Retrieves the referral URLs for the operation
1026 * if <code>continueProcessing</code> returned <code>false</code>.
1027 *
1028 * @return the refferal URLs for the operation or
1029 * <code>null</code> if none is provided.
1030 */
1031 public List<String> getReferralURLs()
1032 {
1033 return referralURLs;
1034 }
1035 }
1036
1037 /**
1038 * Defines an intermediate response plugin result for core server
1039 * operation processing consisting of either continue, skip further
1040 * plugins, or stop operation processing with a result code,
1041 * matched DN, referral URLs, and error message.
1042 */
1043 public static final class IntermediateResponse
1044 {
1045 // Whether to continue operation processing.
1046 private final boolean continueProcessing;
1047
1048 // Whether to invoke the rest of the plugins.
1049 private final boolean continuePluginProcessing;
1050
1051 // Whether to send the intermediate response to the client.
1052 private final boolean sendResponse;
1053
1054 // An message explaining why processing should stop.
1055 private final Message errorMessage;
1056
1057 // The matched DN for this result.
1058 private final DN matchedDN;
1059
1060 // The set of referral URLs for this result.
1061 private final List<String> referralURLs;
1062
1063 // The result code for this result.
1064 private final ResultCode resultCode;
1065
1066 private static IntermediateResponse DEFAULT_RESULT =
1067 new IntermediateResponse(true, true, true, null, null, null,
1068 null);
1069
1070 /**
1071 * Construct a new intermediate response plugin result.
1072 *
1073 * @param continueProcessing Whether to continue startup.
1074 * @param continuePluginProcessing Whether to invoke the rest
1075 * of the plugins.
1076 * @param sendResponse Whether to send the intermediate response
1077 * to the client.
1078 * @param errorMessage An message explaining why processing
1079 * should stop.
1080 * @param resultCode The result code for this result.
1081 * @param matchedDN The matched DN for this result.
1082 * @param referralURLs The set of referral URLs for this result.
1083 * stop.
1084 */
1085 private IntermediateResponse(boolean continueProcessing,
1086 boolean continuePluginProcessing,
1087 boolean sendResponse,
1088 Message errorMessage,
1089 ResultCode resultCode, DN matchedDN,
1090 List<String> referralURLs)
1091 {
1092 this.continueProcessing = continueProcessing;
1093 this.errorMessage = errorMessage;
1094 this.continuePluginProcessing = continuePluginProcessing;
1095 this.resultCode = resultCode;
1096 this.matchedDN = matchedDN;
1097 this.referralURLs = referralURLs;
1098 this.sendResponse = sendResponse;
1099 }
1100
1101 /**
1102 * Defines a continue processing intermediate response plugin
1103 * result.
1104 *
1105 * @param sendResponse Whether to send the intermediate response
1106 * to the client.
1107 * @return a continue processing intermediate response plugin
1108 * result.
1109 */
1110 public static IntermediateResponse
1111 continueOperationProcessing(boolean sendResponse)
1112 {
1113 if(sendResponse)
1114 {
1115 return DEFAULT_RESULT;
1116 }
1117 else
1118 {
1119 return new IntermediateResponse(true, true, sendResponse,
1120 null, null, null, null);
1121 }
1122 }
1123
1124 /**
1125 * Defines a skip further plugin processing intermediate response
1126 * plugin result.
1127 *
1128 * @param sendResponse Whether to send the intermediate response
1129 * to the client.
1130 *
1131 * @return a skip further plugin processing intermediate response
1132 * plugin result.
1133 */
1134 public static IntermediateResponse
1135 skipFurtherPluginProcesssing(boolean sendResponse)
1136 {
1137 return new IntermediateResponse(true, false, sendResponse,
1138 null, null, null, null);
1139 }
1140
1141 /**
1142 * Defines a new stop processing intermediate response plugin
1143 * result.
1144 *
1145 * @param sendResponse Whether to send the intermediate response
1146 * to the client.
1147 * @param resultCode The result code for this result.
1148 * @param errorMessage An message explaining why processing
1149 * should stop.
1150 * @param matchedDN The matched DN for this result.
1151 * @param referralURLs The set of referral URLs for this result.
1152 *
1153 * @return a new stop processing intermediate response plugin
1154 * result.
1155 */
1156 public static IntermediateResponse stopProcessing(
1157 boolean sendResponse, ResultCode resultCode,
1158 Message errorMessage, DN matchedDN, List<String> referralURLs)
1159 {
1160 return new IntermediateResponse(false, false, sendResponse,
1161 errorMessage, resultCode, matchedDN, referralURLs);
1162 }
1163
1164 /**
1165 * Contrust a new stop processing intermediate response plugin
1166 * result.
1167 *
1168 * @param sendResponse Whether to send the intermediate response
1169 * to the client.
1170 * @param resultCode The result code for this result.
1171 * @param errorMessage An message explaining why processing
1172 * should stop.
1173 *
1174 * @return a new stop processing intermediate response plugin
1175 * result.
1176 */
1177 public static IntermediateResponse stopProcessing(
1178 boolean sendResponse, ResultCode resultCode,
1179 Message errorMessage)
1180 {
1181 return new IntermediateResponse(false, false, sendResponse,
1182 errorMessage, resultCode, null, null);
1183 }
1184
1185 /**
1186 * Whether to continue operation processing.
1187 *
1188 * @return <code>true</code> if processing should continue
1189 * or <code>false</code> otherwise.
1190 */
1191 public boolean continueProcessing()
1192 {
1193 return continueProcessing;
1194 }
1195
1196 /**
1197 * Whether to invoke the rest of the plugins.
1198 *
1199 * @return <code>true</code> if the rest of the plugins should
1200 * be invoked for <code>false</code> to skip the rest of the
1201 * plugins.
1202 */
1203 public boolean continuePluginProcessing()
1204 {
1205 return continuePluginProcessing;
1206 }
1207
1208 /**
1209 * Whether to send the intermediate response to the client.
1210 *
1211 * @return <code>true</code> if the intermediate response should
1212 * be sent to the client or <code>false</code> otherwise.
1213 */
1214 public boolean sendResponse()
1215 {
1216 return sendResponse;
1217 }
1218
1219 /**
1220 * Retrieves the error message if <code>continueProcessing</code>
1221 * returned <code>false</code>.
1222 *
1223 * @return An error message explaining why processing should
1224 * stop or <code>null</code> if none is provided.
1225 */
1226 public Message getErrorMessage()
1227 {
1228 return errorMessage;
1229 }
1230
1231 /**
1232 * Retrieves the result code for the operation
1233 * if <code>continueProcessing</code> returned <code>false</code>.
1234 *
1235 * @return the result code for the operation or <code>null</code>
1236 * if none is provided.
1237 */
1238 public ResultCode getResultCode()
1239 {
1240 return resultCode;
1241 }
1242
1243 /**
1244 * Retrieves the matched DN for the operation
1245 * if <code>continueProcessing</code> returned <code>false</code>.
1246 *
1247 * @return the matched DN for the operation or <code>null</code>
1248 * if none is provided.
1249 */
1250 public DN getMatchedDN()
1251 {
1252 return matchedDN;
1253 }
1254
1255 /**
1256 * Retrieves the referral URLs for the operation
1257 * if <code>continueProcessing</code> returned <code>false</code>.
1258 *
1259 * @return the refferal URLs for the operation or
1260 * <code>null</code> if none is provided.
1261 */
1262 public List<String> getReferralURLs()
1263 {
1264 return referralURLs;
1265 }
1266 }
1267
1268 /**
1269 * Defines a post connect plugin result for client connection
1270 * processing consisting of either continue, skip further
1271 * plugins, or stop.
1272 */
1273 public static final class PostConnect
1274 {
1275 // Whether to continue connection processing.
1276 private final boolean continueProcessing;
1277
1278 // Whether to invoke the rest of the plugins.
1279 private final boolean continuePluginProcessing;
1280
1281 // An message explaining why processing should stop.
1282 private final Message errorMessage;
1283
1284 // The disconnect reason that provides the generic cause for the
1285 // disconnect.
1286 private final DisconnectReason disconnectReason;
1287
1288 // Whether to send a disconnect notification to the client.
1289 private final boolean sendDisconnectNotification;
1290
1291 private static PostConnect DEFAULT_RESULT =
1292 new PostConnect(true, true, null, null, false);
1293
1294 /**
1295 * Construct a new post connect plugin result.
1296 *
1297 * @param continueProcessing Whether to continue startup.
1298 * @param continuePluginProcessing Whether to invoke the rest
1299 * of the plugins.
1300 * @param errorMessage An message explaining why processing
1301 * should stop.
1302 * @param disconnectReason The generic cause for the disconnect.
1303 * @param sendDisconnectNotification Whether to send a disconnect
1304 * notification to the client.
1305 */
1306 private PostConnect(boolean continueProcessing,
1307 boolean continuePluginProcessing,
1308 Message errorMessage,
1309 DisconnectReason disconnectReason,
1310 boolean sendDisconnectNotification)
1311 {
1312 this.continueProcessing = continueProcessing;
1313 this.errorMessage = errorMessage;
1314 this.continuePluginProcessing = continuePluginProcessing;
1315 this.disconnectReason = disconnectReason;
1316 this.sendDisconnectNotification = sendDisconnectNotification;
1317 }
1318
1319 /**
1320 * Defines a continue processing post connect plugin result.
1321 *
1322 * @return a continue processing post connect plugin result.
1323 */
1324 public static PostConnect continueConnectProcessing()
1325 {
1326 return DEFAULT_RESULT;
1327 }
1328
1329 /**
1330 * Defines a skip further plugin processing post connect plugin
1331 * result.
1332 *
1333 * @return a skip further plugin processing post connect plugin
1334 * result.
1335 */
1336 public static PostConnect skipFurtherPluginProcesssing()
1337 {
1338 return new PostConnect(true, false, null, null, false);
1339 }
1340
1341 /**
1342 * Defines a new stop processing post connect plugin result.
1343 *
1344 * @param disconnectReason The generic cause for the disconnect.
1345 * @param sendDisconnectNotification Whether to send a disconnect
1346 * notification to the client.
1347 * @param errorMessage An message explaining why processing
1348 * should stop for the given entry.
1349 *
1350 * @return a new stop processing post connect plugin result.
1351 */
1352 public static PostConnect disconnectClient(
1353 DisconnectReason disconnectReason,
1354 boolean sendDisconnectNotification, Message errorMessage)
1355 {
1356 return new PostConnect(false, false, errorMessage,
1357 disconnectReason, sendDisconnectNotification);
1358 }
1359
1360 /**
1361 * Whether to continue operation processing.
1362 *
1363 * @return <code>true</code> if processing should continue
1364 * or <code>false</code> otherwise.
1365 */
1366 public boolean continueProcessing()
1367 {
1368 return continueProcessing;
1369 }
1370
1371 /**
1372 * Whether to invoke the rest of the plugins.
1373 *
1374 * @return <code>true</code> if the rest of the plugins should
1375 * be invoked for <code>false</code> to skip the rest of the
1376 * plugins.
1377 */
1378 public boolean continuePluginProcessing()
1379 {
1380 return continuePluginProcessing;
1381 }
1382
1383 /**
1384 * Retrieves the error message if <code>continueProcessing</code>
1385 * returned <code>false</code>.
1386 *
1387 * @return An error message explaining why processing should
1388 * stop or <code>null</code> if none is provided.
1389 */
1390 public Message getErrorMessage()
1391 {
1392 return errorMessage;
1393 }
1394
1395 /**
1396 * The disconnect reason that provides the generic cause for the
1397 * disconnect.
1398 *
1399 * @return the generic cause for the disconnect.
1400 */
1401 public DisconnectReason getDisconnectReason()
1402 {
1403 return disconnectReason;
1404 }
1405
1406 /**
1407 * Indicates whether to try to provide notification to the client
1408 * that the connection will be closed.
1409 *
1410 * @return <code>true</code> if notification should be provided or
1411 * <code>false</code> otherwise.
1412 */
1413 public boolean sendDisconnectNotification()
1414 {
1415 return sendDisconnectNotification;
1416 }
1417 }
1418
1419 /**
1420 * Defines a post disconnect plugin result for client connection
1421 * processing consisting of either continue or skip further
1422 * plugins.
1423 */
1424 public static final class PostDisconnect
1425 {
1426 // Whether to invoke the rest of the plugins.
1427 private final boolean continuePluginProcessing;
1428
1429 private static PostDisconnect DEFAULT_RESULT =
1430 new PostDisconnect(true);
1431
1432 /**
1433 * Construct a new post disconnect plugin result.
1434 *
1435 * @param continuePluginProcessing Whether to invoke the rest
1436 * of the plugins.
1437 */
1438 private PostDisconnect(boolean continuePluginProcessing)
1439 {
1440 this.continuePluginProcessing = continuePluginProcessing;
1441 }
1442
1443 /**
1444 * Defines a continue processing post disconnect plugin result.
1445 *
1446 * @return a continue processing post disconnect plugin result.
1447 */
1448 public static PostDisconnect continueDisconnectProcessing()
1449 {
1450 return DEFAULT_RESULT;
1451 }
1452
1453 /**
1454 * Defines a skip further plugin processing post disconnect
1455 * plugin result.
1456 *
1457 * @return a skip further plugin processing post disconnect
1458 * plugin result.
1459 */
1460 public static PostDisconnect skipFurtherPluginProcesssing()
1461 {
1462 return new PostDisconnect(false);
1463 }
1464
1465 /**
1466 * Whether to invoke the rest of the plugins.
1467 *
1468 * @return <code>true</code> if the rest of the plugins should
1469 * be invoked for <code>false</code> to skip the rest of the
1470 * plugins.
1471 */
1472 public boolean continuePluginProcessing()
1473 {
1474 return continuePluginProcessing;
1475 }
1476 }
1477 }