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
180 public ExecutorFilter(int maximumPoolSize) {
181
182 Executor executor = createDefaultExecutor(
183 BASE_THREAD_NUMBER,
184 maximumPoolSize,
185 DEFAULT_KEEPALIVE_TIME,
186 TimeUnit.SECONDS,
187 Executors.defaultThreadFactory(),
188 null);
189
190
191 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
192 }
193
194
195
196
197
198
199
200
201
202
203
204 public ExecutorFilter(int corePoolSize, int maximumPoolSize) {
205
206 Executor executor = createDefaultExecutor(
207 corePoolSize,
208 maximumPoolSize,
209 DEFAULT_KEEPALIVE_TIME,
210 TimeUnit.SECONDS,
211 Executors.defaultThreadFactory(),
212 null);
213
214
215 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
216 }
217
218
219
220
221
222 public ExecutorFilter(int corePoolSize, int maximumPoolSize, long keepAliveTime,
223 TimeUnit unit) {
224
225 Executor executor = createDefaultExecutor(
226 corePoolSize,
227 maximumPoolSize,
228 keepAliveTime,
229 unit,
230 Executors.defaultThreadFactory(),
231 null);
232
233
234 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
235 }
236
237
238
239
240
241 public ExecutorFilter(
242 int corePoolSize, int maximumPoolSize,
243 long keepAliveTime, TimeUnit unit,
244 IoEventQueueHandler queueHandler) {
245
246 Executor executor = createDefaultExecutor(
247 corePoolSize,
248 maximumPoolSize,
249 keepAliveTime,
250 unit,
251 Executors.defaultThreadFactory(),
252 queueHandler);
253
254
255 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
256 }
257
258
259
260
261
262 public ExecutorFilter(
263 int corePoolSize, int maximumPoolSize,
264 long keepAliveTime, TimeUnit unit,
265 ThreadFactory threadFactory) {
266
267 Executor executor = createDefaultExecutor(
268 corePoolSize,
269 maximumPoolSize,
270 keepAliveTime,
271 unit,
272 threadFactory,
273 null);
274
275
276 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
277 }
278
279
280
281
282
283 public ExecutorFilter(
284 int corePoolSize, int maximumPoolSize,
285 long keepAliveTime, TimeUnit unit,
286 ThreadFactory threadFactory, IoEventQueueHandler queueHandler) {
287
288 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, threadFactory, queueHandler);
289
290
291 init(executor, MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
292 }
293
294
295
296
297
298 public ExecutorFilter(IoEventType... eventTypes) {
299
300 Executor executor = createDefaultExecutor(
301 BASE_THREAD_NUMBER,
302 DEFAULT_MAX_POOL_SIZE,
303 DEFAULT_KEEPALIVE_TIME,
304 TimeUnit.SECONDS,
305 Executors.defaultThreadFactory(),
306 null);
307
308
309 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
310 }
311
312
313
314
315
316 public ExecutorFilter(int maximumPoolSize, IoEventType... eventTypes) {
317
318 Executor executor = createDefaultExecutor(
319 BASE_THREAD_NUMBER,
320 maximumPoolSize,
321 DEFAULT_KEEPALIVE_TIME,
322 TimeUnit.SECONDS,
323 Executors.defaultThreadFactory(),
324 null);
325
326
327 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
328 }
329
330
331
332
333
334 public ExecutorFilter(int corePoolSize, int maximumPoolSize, IoEventType... eventTypes) {
335
336 Executor executor = createDefaultExecutor(
337 corePoolSize,
338 maximumPoolSize,
339 DEFAULT_KEEPALIVE_TIME,
340 TimeUnit.SECONDS,
341 Executors.defaultThreadFactory(),
342 null);
343
344
345 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
346 }
347
348
349
350
351
352 public ExecutorFilter(
353 int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, IoEventType... eventTypes) {
354
355 Executor executor = createDefaultExecutor(
356 corePoolSize,
357 maximumPoolSize,
358 keepAliveTime,
359 unit,
360 Executors.defaultThreadFactory(),
361 null);
362
363
364 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
365 }
366
367
368
369
370
371 public ExecutorFilter(
372 int corePoolSize, int maximumPoolSize,
373 long keepAliveTime, TimeUnit unit,
374 IoEventQueueHandler queueHandler, IoEventType... eventTypes) {
375
376 Executor executor = createDefaultExecutor(
377 corePoolSize,
378 maximumPoolSize,
379 keepAliveTime,
380 unit,
381 Executors.defaultThreadFactory(),
382 queueHandler);
383
384
385 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
386 }
387
388
389
390
391
392 public ExecutorFilter(
393 int corePoolSize, int maximumPoolSize,
394 long keepAliveTime, TimeUnit unit,
395 ThreadFactory threadFactory, IoEventType... eventTypes) {
396
397 Executor executor = createDefaultExecutor(
398 corePoolSize,
399 maximumPoolSize,
400 keepAliveTime,
401 unit,
402 threadFactory,
403 null);
404
405
406 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
407 }
408
409
410
411
412
413
414
415
416
417
418
419
420
421 public ExecutorFilter(
422 int corePoolSize, int maximumPoolSize,
423 long keepAliveTime, TimeUnit unit,
424 ThreadFactory threadFactory, IoEventQueueHandler queueHandler,
425 IoEventType... eventTypes) {
426
427 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize,
428 keepAliveTime, unit, threadFactory, queueHandler);
429
430
431 init(executor, MANAGEABLE_EXECUTOR, eventTypes);
432 }
433
434
435
436
437 public ExecutorFilter(Executor executor) {
438
439 init(executor, NOT_MANAGEABLE_EXECUTOR, DEFAULT_EVENT_SET);
440 }
441
442
443
444
445 public ExecutorFilter(Executor executor, IoEventType... eventTypes) {
446
447 init(executor, NOT_MANAGEABLE_EXECUTOR, eventTypes);
448 }
449
450
451
452
453
454
455
456
457
458
459
460
461 private Executor createDefaultExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
462 TimeUnit unit, ThreadFactory threadFactory, IoEventQueueHandler queueHandler) {
463
464 Executor executor = new OrderedThreadPoolExecutor(corePoolSize, maximumPoolSize,
465 keepAliveTime, unit, threadFactory, queueHandler);
466
467 return executor;
468 }
469
470
471
472
473
474
475
476 private void initEventTypes(IoEventType... eventTypes) {
477 if (eventTypes == null || eventTypes.length == 0) {
478 eventTypes = DEFAULT_EVENT_SET;
479 }
480
481
482 this.eventTypes = EnumSet.of(eventTypes[0], eventTypes);
483
484
485 if (this.eventTypes.contains( IoEventType.SESSION_CREATED )) {
486 this.eventTypes = null;
487 throw new IllegalArgumentException(IoEventType.SESSION_CREATED
488 + " is not allowed.");
489 }
490 }
491
492
493
494
495
496
497
498
499
500
501 private void init(Executor executor, boolean manageableExecutor, IoEventType... eventTypes) {
502 if (executor == null) {
503 throw new NullPointerException("executor");
504 }
505
506 initEventTypes(eventTypes);
507 this.executor = executor;
508 this.manageableExecutor = manageableExecutor;
509 }
510
511
512
513
514
515 @Override
516 public void destroy() {
517 if (manageableExecutor) {
518 ((ExecutorService) executor).shutdown();
519 }
520 }
521
522
523
524
525
526
527 public final Executor getExecutor() {
528 return executor;
529 }
530
531
532
533
534 protected void fireEvent(IoFilterEvent event) {
535 getExecutor().execute(event);
536 }
537
538
539
540
541
542
543
544
545
546
547
548
549 @Override
550 public void onPreAdd(IoFilterChain parent, String name,
551 NextFilter nextFilter) throws Exception {
552 if (parent.contains(this)) {
553 throw new IllegalArgumentException(
554 "You can't add the same filter instance more than once. Create another instance and add it.");
555 }
556 }
557
558 @Override
559 public final void sessionOpened(NextFilter nextFilter, IoSession session) {
560 if (eventTypes.contains(IoEventType.SESSION_OPENED)) {
561 fireEvent(new IoFilterEvent(nextFilter, IoEventType.SESSION_OPENED,
562 session, null));
563 } else {
564 nextFilter.sessionOpened(session);
565 }
566 }
567
568 @Override
569 public final void sessionClosed(NextFilter nextFilter, IoSession session) {
570 if (eventTypes.contains(IoEventType.SESSION_CLOSED)) {
571 fireEvent(new IoFilterEvent(nextFilter, IoEventType.SESSION_CLOSED,
572 session, null));
573 } else {
574 nextFilter.sessionClosed(session);
575 }
576 }
577
578 @Override
579 public final void sessionIdle(NextFilter nextFilter, IoSession session,
580 IdleStatus status) {
581 if (eventTypes.contains(IoEventType.SESSION_IDLE)) {
582 fireEvent(new IoFilterEvent(nextFilter, IoEventType.SESSION_IDLE,
583 session, status));
584 } else {
585 nextFilter.sessionIdle(session, status);
586 }
587 }
588
589 @Override
590 public final void exceptionCaught(NextFilter nextFilter, IoSession session,
591 Throwable cause) {
592 if (eventTypes.contains(IoEventType.EXCEPTION_CAUGHT)) {
593 fireEvent(new IoFilterEvent(nextFilter,
594 IoEventType.EXCEPTION_CAUGHT, session, cause));
595 } else {
596 nextFilter.exceptionCaught(session, cause);
597 }
598 }
599
600 @Override
601 public final void messageReceived(NextFilter nextFilter, IoSession session,
602 Object message) {
603 if (eventTypes.contains(IoEventType.MESSAGE_RECEIVED)) {
604 fireEvent(new IoFilterEvent(nextFilter,
605 IoEventType.MESSAGE_RECEIVED, session, message));
606 } else {
607 nextFilter.messageReceived(session, message);
608 }
609 }
610
611 @Override
612 public final void messageSent(NextFilter nextFilter, IoSession session,
613 WriteRequest writeRequest) {
614 if (eventTypes.contains(IoEventType.MESSAGE_SENT)) {
615 fireEvent(new IoFilterEvent(nextFilter, IoEventType.MESSAGE_SENT,
616 session, writeRequest));
617 } else {
618 nextFilter.messageSent(session, writeRequest);
619 }
620 }
621
622 @Override
623 public final void filterWrite(NextFilter nextFilter, IoSession session,
624 WriteRequest writeRequest) {
625 if (eventTypes.contains(IoEventType.WRITE)) {
626 fireEvent(new IoFilterEvent(nextFilter, IoEventType.WRITE, session,
627 writeRequest));
628 } else {
629 nextFilter.filterWrite(session, writeRequest);
630 }
631 }
632
633 @Override
634 public final void filterClose(NextFilter nextFilter, IoSession session)
635 throws Exception {
636 if (eventTypes.contains(IoEventType.CLOSE)) {
637 fireEvent(new IoFilterEvent(nextFilter, IoEventType.CLOSE, session,
638 null));
639 } else {
640 nextFilter.filterClose(session);
641 }
642 }
643 }