1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.mina.filter.executor;
21
22 import java.util.EnumSet;
23 import java.util.concurrent.Executor;
24 import java.util.concurrent.ExecutorService;
25 import java.util.concurrent.Executors;
26 import java.util.concurrent.ThreadFactory;
27 import java.util.concurrent.TimeUnit;
28
29 import org.apache.mina.core.filterchain.IoFilterAdapter;
30 import org.apache.mina.core.filterchain.IoFilterChain;
31 import org.apache.mina.core.filterchain.IoFilterEvent;
32 import org.apache.mina.core.session.IdleStatus;
33 import org.apache.mina.core.session.IoEventType;
34 import org.apache.mina.core.session.IoSession;
35 import org.apache.mina.core.write.WriteRequest;
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113 public class ExecutorFilter extends IoFilterAdapter {
114
115 private EnumSet<IoEventType> eventTypes;
116
117
118 private Executor executor;
119
120
121 private boolean manageableExecutor;
122
123
124 private static final int DEFAULT_MAX_POOL_SIZE = 16;
125
126
127 private static final int BASE_THREAD_NUMBER = 0;
128
129
130 private static final long DEFAULT_KEEPALIVE_TIME = 30;
131
132
133
134
135
136
137 private static final boolean MANAGEABLE_EXECUTOR = true;
138 private static final boolean NOT_MANAGEABLE_EXECUTOR = false;
139
140
141 private static IoEventType[] DEFAULT_EVENT_SET = new IoEventType[] {
142 IoEventType.EXCEPTION_CAUGHT,
143 IoEventType.MESSAGE_RECEIVED,
144 IoEventType.MESSAGE_SENT,
145 IoEventType.SESSION_CLOSED,
146 IoEventType.SESSION_IDLE,
147 IoEventType.SESSION_OPENED
148 };
149
150
151
152
153
154
155
156
157 public ExecutorFilter() {
158
159 Executor executor = createDefaultExecutor(
160 BASE_THREAD_NUMBER,
161 DEFAULT_MAX_POOL_SIZE,
162 DEFAULT_KEEPALIVE_TIME,
163 TimeUnit.SECONDS,
164 Executors.defaultThreadFactory(),
165 null);
166
167
168 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
169 }
170
171
172
173
174
175
176
177
178
179 public ExecutorFilter(int maximumPoolSize) {
180
181 Executor executor = createDefaultExecutor(
182 BASE_THREAD_NUMBER,
183 maximumPoolSize,
184 DEFAULT_KEEPALIVE_TIME,
185 TimeUnit.SECONDS,
186 Executors.defaultThreadFactory(),
187 null);
188
189
190 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
191 }
192
193
194
195
196
197
198
199
200
201
202 public ExecutorFilter(int corePoolSize, int maximumPoolSize) {
203
204 Executor executor = createDefaultExecutor(
205 corePoolSize,
206 maximumPoolSize,
207 DEFAULT_KEEPALIVE_TIME,
208 TimeUnit.SECONDS,
209 Executors.defaultThreadFactory(),
210 null);
211
212
213 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
214 }
215
216
217
218
219
220
221
222
223
224
225 public ExecutorFilter(int corePoolSize, int maximumPoolSize, long keepAliveTime,
226 TimeUnit unit) {
227
228 Executor executor = createDefaultExecutor(
229 corePoolSize,
230 maximumPoolSize,
231 keepAliveTime,
232 unit,
233 Executors.defaultThreadFactory(),
234 null);
235
236
237 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
238 }
239
240
241
242
243
244
245
246
247
248
249
250 public ExecutorFilter(
251 int corePoolSize, int maximumPoolSize,
252 long keepAliveTime, TimeUnit unit,
253 IoEventQueueHandler queueHandler) {
254
255 Executor executor = createDefaultExecutor(
256 corePoolSize,
257 maximumPoolSize,
258 keepAliveTime,
259 unit,
260 Executors.defaultThreadFactory(),
261 queueHandler);
262
263
264 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
265 }
266
267
268
269
270
271
272
273
274
275
276
277 public ExecutorFilter(
278 int corePoolSize, int maximumPoolSize,
279 long keepAliveTime, TimeUnit unit,
280 ThreadFactory threadFactory) {
281
282 Executor executor = createDefaultExecutor(
283 corePoolSize,
284 maximumPoolSize,
285 keepAliveTime,
286 unit,
287 threadFactory,
288 null);
289
290
291 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
292 }
293
294
295
296
297
298
299
300
301
302
303
304
305 public ExecutorFilter(
306 int corePoolSize, int maximumPoolSize,
307 long keepAliveTime, TimeUnit unit,
308 ThreadFactory threadFactory, IoEventQueueHandler queueHandler) {
309
310 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, threadFactory, queueHandler);
311
312
313 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
314 }
315
316
317
318
319
320
321
322 public ExecutorFilter(IoEventType... eventTypes) {
323
324 Executor executor = createDefaultExecutor(
325 BASE_THREAD_NUMBER,
326 DEFAULT_MAX_POOL_SIZE,
327 DEFAULT_KEEPALIVE_TIME,
328 TimeUnit.SECONDS,
329 Executors.defaultThreadFactory(),
330 null);
331
332
333 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
334 }
335
336
337
338
339
340
341
342
343 public ExecutorFilter(int maximumPoolSize, IoEventType... eventTypes) {
344
345 Executor executor = createDefaultExecutor(
346 BASE_THREAD_NUMBER,
347 maximumPoolSize,
348 DEFAULT_KEEPALIVE_TIME,
349 TimeUnit.SECONDS,
350 Executors.defaultThreadFactory(),
351 null);
352
353
354 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
355 }
356
357
358
359
360
361
362
363
364
365 public ExecutorFilter(int corePoolSize, int maximumPoolSize, IoEventType... eventTypes) {
366
367 Executor executor = createDefaultExecutor(
368 corePoolSize,
369 maximumPoolSize,
370 DEFAULT_KEEPALIVE_TIME,
371 TimeUnit.SECONDS,
372 Executors.defaultThreadFactory(),
373 null);
374
375
376 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
377 }
378
379
380
381
382
383
384
385
386
387
388
389 public ExecutorFilter(
390 int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
391 IoEventType... eventTypes) {
392
393 Executor executor = createDefaultExecutor(
394 corePoolSize,
395 maximumPoolSize,
396 keepAliveTime,
397 unit,
398 Executors.defaultThreadFactory(),
399 null);
400
401
402 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
403 }
404
405
406
407
408
409
410
411
412
413
414
415
416 public ExecutorFilter(
417 int corePoolSize, int maximumPoolSize,
418 long keepAliveTime, TimeUnit unit,
419 IoEventQueueHandler queueHandler, IoEventType... eventTypes) {
420
421 Executor executor = createDefaultExecutor(
422 corePoolSize,
423 maximumPoolSize,
424 keepAliveTime,
425 unit,
426 Executors.defaultThreadFactory(),
427 queueHandler);
428
429
430 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
431 }
432
433
434
435
436
437
438
439
440
441
442
443
444 public ExecutorFilter(
445 int corePoolSize, int maximumPoolSize,
446 long keepAliveTime, TimeUnit unit,
447 ThreadFactory threadFactory, IoEventType... eventTypes) {
448
449 Executor executor = createDefaultExecutor(
450 corePoolSize,
451 maximumPoolSize,
452 keepAliveTime,
453 unit,
454 threadFactory,
455 null);
456
457
458 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
459 }
460
461
462
463
464
465
466
467
468
469
470
471
472
473 public ExecutorFilter(
474 int corePoolSize, int maximumPoolSize,
475 long keepAliveTime, TimeUnit unit,
476 ThreadFactory threadFactory, IoEventQueueHandler queueHandler,
477 IoEventType... eventTypes) {
478
479 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize,
480 keepAliveTime, unit, threadFactory, queueHandler);
481
482
483 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
484 }
485
486
487
488
489
490
491 public ExecutorFilter(Executor executor) {
492
493 init(executor, NOT_MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
494 }
495
496
497
498
499
500
501
502 public ExecutorFilter(Executor executor, IoEventType... eventTypes) {
503
504 init(executor, NOT_MANAGEABLE_EXECUTOR, eventTypes);
505 }
506
507
508
509
510
511
512
513
514
515
516
517
518 private Executor createDefaultExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
519 TimeUnit unit, ThreadFactory threadFactory, IoEventQueueHandler queueHandler) {
520
521 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize,
522 keepAliveTime, unit, threadFactory, queueHandler);
523
524 return executor;
525 }
526
527
528
529
530
531
532
533 private void initEventTypes(IoEventType... eventTypes) {
534 if ((eventTypes == null) || (eventTypes.length == 0)) {
535 eventTypes = DEFAULT_EVENT_SET;
536 }
537
538
539 this.eventTypes = EnumSet.of(eventTypes[0], eventTypes);
540
541
542 if (this.eventTypes.contains( IoEventType.SESSION_CREATED )) {
543 this.eventTypes = null;
544 throw new IllegalArgumentException(IoEventType.SESSION_CREATED
545 + " is not allowed.");
546 }
547 }
548
549
550
551
552
553
554
555
556
557
558 private void init(Executor executor, boolean manageableExecutor, IoEventType... eventTypes) {
559 if (executor == null) {
560 throw new NullPointerException("executor");
561 }
562
563 initEventTypes(eventTypes);
564 this.executor = executor;
565 this.manageableExecutor = manageableExecutor;
566 }
567
568
569
570
571
572 @Override
573 public void destroy() {
574 if (manageableExecutor) {
575 ((ExecutorService) executor).shutdown();
576 }
577 }
578
579
580
581
582
583
584 public final Executor getExecutor() {
585 return executor;
586 }
587
588
589
590
591 protected void fireEvent(IoFilterEvent event) {
592 getExecutor().execute(event);
593 }
594
595
596
597
598
599
600
601
602
603
604
605
606 @Override
607 public void onPreAdd(IoFilterChain parent, String name,
608 NextFilter nextFilter) throws Exception {
609 if (parent.contains(this)) {
610 throw new IllegalArgumentException(
611 "You can't add the same filter instance more than once. Create another instance and add it.");
612 }
613 }
614
615
616
617
618 @Override
619 public final void sessionOpened(NextFilter nextFilter, IoSession session) {
620 if (eventTypes.contains(IoEventType.SESSION_OPENED)) {
621 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.SESSION_OPENED,
622 session, null);
623 fireEvent(event);
624 } else {
625 nextFilter.sessionOpened(session);
626 }
627 }
628
629
630
631
632 @Override
633 public final void sessionClosed(NextFilter nextFilter, IoSession session) {
634 if (eventTypes.contains(IoEventType.SESSION_CLOSED)) {
635 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.SESSION_CLOSED,
636 session, null);
637 fireEvent(event);
638 } else {
639 nextFilter.sessionClosed(session);
640 }
641 }
642
643
644
645
646 @Override
647 public final void sessionIdle(NextFilter nextFilter, IoSession session,
648 IdleStatus status) {
649 if (eventTypes.contains(IoEventType.SESSION_IDLE)) {
650 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.SESSION_IDLE,
651 session, status);
652 fireEvent(event);
653 } else {
654 nextFilter.sessionIdle(session, status);
655 }
656 }
657
658
659
660
661 @Override
662 public final void exceptionCaught(NextFilter nextFilter, IoSession session,
663 Throwable cause) {
664 if (eventTypes.contains(IoEventType.EXCEPTION_CAUGHT)) {
665 IoFilterEvent event = new IoFilterEvent(nextFilter,
666 IoEventType.EXCEPTION_CAUGHT, session, cause);
667 fireEvent(event);
668 } else {
669 nextFilter.exceptionCaught(session, cause);
670 }
671 }
672
673
674
675
676 @Override
677 public final void messageReceived(NextFilter nextFilter, IoSession session,
678 Object message) {
679 if (eventTypes.contains(IoEventType.MESSAGE_RECEIVED)) {
680 IoFilterEvent event = new IoFilterEvent(nextFilter,
681 IoEventType.MESSAGE_RECEIVED, session, message);
682 fireEvent(event);
683 } else {
684 nextFilter.messageReceived(session, message);
685 }
686 }
687
688
689
690
691 @Override
692 public final void messageSent(NextFilter nextFilter, IoSession session,
693 WriteRequest writeRequest) {
694 if (eventTypes.contains(IoEventType.MESSAGE_SENT)) {
695 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.MESSAGE_SENT,
696 session, writeRequest);
697 fireEvent(event);
698 } else {
699 nextFilter.messageSent(session, writeRequest);
700 }
701 }
702
703
704
705
706 @Override
707 public final void filterWrite(NextFilter nextFilter, IoSession session,
708 WriteRequest writeRequest) {
709 if (eventTypes.contains(IoEventType.WRITE)) {
710 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.WRITE, session,
711 writeRequest);
712 fireEvent(event);
713 } else {
714 nextFilter.filterWrite(session, writeRequest);
715 }
716 }
717
718
719
720
721 @Override
722 public final void filterClose(NextFilter nextFilter, IoSession session)
723 throws Exception {
724 if (eventTypes.contains(IoEventType.CLOSE)) {
725 IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.CLOSE, session,
726 null);
727 fireEvent(event);
728 } else {
729 nextFilter.filterClose(session);
730 }
731 }
732 }