1 /*
2  * Copyright 2019 The Netty Project
3  *
4  * The Netty Project licenses this file to you under the Apache License,
5  * version 2.0 (the "License"); you may not use this file except in compliance
6  * with the License. You may obtain a copy of the License at:
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations
14  * under the License.
15  */
16 package io.netty.channel;
17
18 import io.netty.util.concurrent.FastThreadLocal;
19 import io.netty.util.internal.PlatformDependent;
20
21 import io.netty.util.internal.logging.InternalLogger;
22 import io.netty.util.internal.logging.InternalLoggerFactory;
23 import java.lang.annotation.ElementType;
24 import java.lang.annotation.Inherited;
25 import java.lang.annotation.Retention;
26 import java.lang.annotation.RetentionPolicy;
27 import java.lang.annotation.Target;
28 import java.lang.reflect.Method;
29 import java.net.SocketAddress;
30 import java.security.AccessController;
31 import java.security.PrivilegedExceptionAction;
32 import java.util.Map;
33 import java.util.WeakHashMap;
34
35 final class ChannelHandlerMask {
36     private static final InternalLogger logger = InternalLoggerFactory.getInstance(ChannelHandlerMask.class);
37
38     // Using to mask which methods must be called for a ChannelHandler.
39     static final int MASK_EXCEPTION_CAUGHT = 1;
40     static final int MASK_CHANNEL_REGISTERED = 1 << 1;
41     static final int MASK_CHANNEL_UNREGISTERED = 1 << 2;
42     static final int MASK_CHANNEL_ACTIVE = 1 << 3;
43     static final int MASK_CHANNEL_INACTIVE = 1 << 4;
44     static final int MASK_CHANNEL_READ = 1 << 5;
45     static final int MASK_CHANNEL_READ_COMPLETE = 1 << 6;
46     static final int MASK_USER_EVENT_TRIGGERED = 1 << 7;
47     static final int MASK_CHANNEL_WRITABILITY_CHANGED = 1 << 8;
48     static final int MASK_BIND = 1 << 9;
49     static final int MASK_CONNECT = 1 << 10;
50     static final int MASK_DISCONNECT = 1 << 11;
51     static final int MASK_CLOSE = 1 << 12;
52     static final int MASK_DEREGISTER = 1 << 13;
53     static final int MASK_READ = 1 << 14;
54     static final int MASK_WRITE = 1 << 15;
55     static final int MASK_FLUSH = 1 << 16;
56
57     static final int MASK_ONLY_INBOUND =  MASK_CHANNEL_REGISTERED |
58             MASK_CHANNEL_UNREGISTERED | MASK_CHANNEL_ACTIVE | MASK_CHANNEL_INACTIVE | MASK_CHANNEL_READ |
59             MASK_CHANNEL_READ_COMPLETE | MASK_USER_EVENT_TRIGGERED | MASK_CHANNEL_WRITABILITY_CHANGED;
60     private static final int MASK_ALL_INBOUND = MASK_EXCEPTION_CAUGHT | MASK_ONLY_INBOUND;
61     static final int MASK_ONLY_OUTBOUND =  MASK_BIND | MASK_CONNECT | MASK_DISCONNECT |
62             MASK_CLOSE | MASK_DEREGISTER | MASK_READ | MASK_WRITE | MASK_FLUSH;
63     private static final int MASK_ALL_OUTBOUND = MASK_EXCEPTION_CAUGHT | MASK_ONLY_OUTBOUND;
64
65     private static final FastThreadLocal<Map<Class<? extends ChannelHandler>, Integer>> MASKS =
66             new FastThreadLocal<Map<Class<? extends ChannelHandler>, Integer>>() {
67                 @Override
68                 protected Map<Class<? extends ChannelHandler>, Integer> initialValue() {
69                     return new WeakHashMap<Class<? extends ChannelHandler>, Integer>(32);
70                 }
71             };
72
73     /**
74      * Return the {@code executionMask}.
75      */
76     static int mask(Class<? extends ChannelHandler> clazz) {
77         // Try to obtain the mask from the cache first. If this fails calculate it and put it in the cache for fast
78         // lookup in the future.
79         Map<Class<? extends ChannelHandler>, Integer> cache = MASKS.get();
80         Integer mask = cache.get(clazz);
81         if (mask == null) {
82             mask = mask0(clazz);
83             cache.put(clazz, mask);
84         }
85         return mask;
86     }
87
88     /**
89      * Calculate the {@code executionMask}.
90      */
91     private static int mask0(Class<? extends ChannelHandler> handlerType) {
92         int mask = MASK_EXCEPTION_CAUGHT;
93         try {
94             if (ChannelInboundHandler.class.isAssignableFrom(handlerType)) {
95                 mask |= MASK_ALL_INBOUND;
96
97                 if (isSkippable(handlerType, "channelRegistered", ChannelHandlerContext.class)) {
98                     mask &= ~MASK_CHANNEL_REGISTERED;
99                 }
100                 if (isSkippable(handlerType, "channelUnregistered", ChannelHandlerContext.class)) {
101                     mask &= ~MASK_CHANNEL_UNREGISTERED;
102                 }
103                 if (isSkippable(handlerType, "channelActive", ChannelHandlerContext.class)) {
104                     mask &= ~MASK_CHANNEL_ACTIVE;
105                 }
106                 if (isSkippable(handlerType, "channelInactive", ChannelHandlerContext.class)) {
107                     mask &= ~MASK_CHANNEL_INACTIVE;
108                 }
109                 if (isSkippable(handlerType, "channelRead", ChannelHandlerContext.class, Object.class)) {
110                     mask &= ~MASK_CHANNEL_READ;
111                 }
112                 if (isSkippable(handlerType, "channelReadComplete", ChannelHandlerContext.class)) {
113                     mask &= ~MASK_CHANNEL_READ_COMPLETE;
114                 }
115                 if (isSkippable(handlerType, "channelWritabilityChanged", ChannelHandlerContext.class)) {
116                     mask &= ~MASK_CHANNEL_WRITABILITY_CHANGED;
117                 }
118                 if (isSkippable(handlerType, "userEventTriggered", ChannelHandlerContext.class, Object.class)) {
119                     mask &= ~MASK_USER_EVENT_TRIGGERED;
120                 }
121             }
122
123             if (ChannelOutboundHandler.class.isAssignableFrom(handlerType)) {
124                 mask |= MASK_ALL_OUTBOUND;
125
126                 if (isSkippable(handlerType, "bind", ChannelHandlerContext.class,
127                         SocketAddress.class, ChannelPromise.class)) {
128                     mask &= ~MASK_BIND;
129                 }
130                 if (isSkippable(handlerType, "connect", ChannelHandlerContext.class, SocketAddress.class,
131                         SocketAddress.class, ChannelPromise.class)) {
132                     mask &= ~MASK_CONNECT;
133                 }
134                 if (isSkippable(handlerType, "disconnect", ChannelHandlerContext.class, ChannelPromise.class)) {
135                     mask &= ~MASK_DISCONNECT;
136                 }
137                 if (isSkippable(handlerType, "close", ChannelHandlerContext.class, ChannelPromise.class)) {
138                     mask &= ~MASK_CLOSE;
139                 }
140                 if (isSkippable(handlerType, "deregister", ChannelHandlerContext.class, ChannelPromise.class)) {
141                     mask &= ~MASK_DEREGISTER;
142                 }
143                 if (isSkippable(handlerType, "read", ChannelHandlerContext.class)) {
144                     mask &= ~MASK_READ;
145                 }
146                 if (isSkippable(handlerType, "write", ChannelHandlerContext.class,
147                         Object.class, ChannelPromise.class)) {
148                     mask &= ~MASK_WRITE;
149                 }
150                 if (isSkippable(handlerType, "flush", ChannelHandlerContext.class)) {
151                     mask &= ~MASK_FLUSH;
152                 }
153             }
154
155             if (isSkippable(handlerType, "exceptionCaught", ChannelHandlerContext.class, Throwable.class)) {
156                 mask &= ~MASK_EXCEPTION_CAUGHT;
157             }
158         } catch (Exception e) {
159             // Should never reach here.
160             PlatformDependent.throwException(e);
161         }
162
163         return mask;
164     }
165
166     @SuppressWarnings("rawtypes")
167     private static boolean isSkippable(
168             final Class<?> handlerType, final String methodName, final Class<?>... paramTypes) throws Exception {
169         return AccessController.doPrivileged(new PrivilegedExceptionAction<Boolean>() {
170             @Override
171             public Boolean run() throws Exception {
172                 Method m;
173                 try {
174                     m = handlerType.getMethod(methodName, paramTypes);
175                 } catch (NoSuchMethodException e) {
176                     if (logger.isDebugEnabled()) {
177                         logger.debug(
178                             "Class {} missing method {}, assume we can not skip execution", handlerType, methodName, e);
179                     }
180                     return false;
181                 }
182                 return m != null && m.isAnnotationPresent(Skip.class);
183             }
184         });
185     }
186
187     private ChannelHandlerMask() { }
188
189     /**
190      * Indicates that the annotated event handler method in {@link ChannelHandler} will not be invoked by
191      * {@link ChannelPipeline} and so <strong>MUST</strong> only be used when the {@link ChannelHandler}
192      * method does nothing except forward to the next {@link ChannelHandler} in the pipeline.
193      * <p>
194      * Note that this annotation is not {@linkplain Inherited inherited}. If a user overrides a method annotated with
195      * {@link Skip}, it will not be skipped anymore. Similarly, the user can override a method not annotated with
196      * {@link Skip} and simply pass the event through to the next handler, which reverses the behavior of the
197      * supertype.
198      * </p>
199      */
200     @Target(ElementType.METHOD)
201     @Retention(RetentionPolicy.RUNTIME)
202     @interface Skip {
203         // no value
204     }
205 }
206