1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.jboss.netty.channel.socket;
17
18 import java.io.IOException;
19 import java.net.DatagramSocket;
20 import java.net.InetAddress;
21 import java.net.MulticastSocket;
22 import java.net.NetworkInterface;
23 import java.net.SocketException;
24
25 import org.jboss.netty.channel.ChannelException;
26 import org.jboss.netty.channel.DefaultChannelConfig;
27 import org.jboss.netty.channel.FixedReceiveBufferSizePredictorFactory;
28 import org.jboss.netty.channel.ReceiveBufferSizePredictor;
29 import org.jboss.netty.channel.ReceiveBufferSizePredictorFactory;
30 import org.jboss.netty.util.internal.ConversionUtil;
31
32
33
34
35
36
37
38
39
40
41 public class DefaultDatagramChannelConfig extends DefaultChannelConfig
42 implements DatagramChannelConfig {
43
44 private static final ReceiveBufferSizePredictorFactory DEFAULT_PREDICTOR_FACTORY =
45 new FixedReceiveBufferSizePredictorFactory(768);
46
47 private final DatagramSocket socket;
48 private volatile ReceiveBufferSizePredictor predictor;
49 private volatile ReceiveBufferSizePredictorFactory predictorFactory = DEFAULT_PREDICTOR_FACTORY;
50
51
52
53
54 public DefaultDatagramChannelConfig(DatagramSocket socket) {
55 if (socket == null) {
56 throw new NullPointerException("socket");
57 }
58 this.socket = socket;
59 }
60
61 @Override
62 public boolean setOption(String key, Object value) {
63 if (super.setOption(key, value)) {
64 return true;
65 }
66
67 if (key.equals("broadcast")) {
68 setBroadcast(ConversionUtil.toBoolean(value));
69 } else if (key.equals("receiveBufferSize")) {
70 setReceiveBufferSize(ConversionUtil.toInt(value));
71 } else if (key.equals("sendBufferSize")) {
72 setSendBufferSize(ConversionUtil.toInt(value));
73 } else if (key.equals("receiveBufferSizePredictorFactory")) {
74 setReceiveBufferSizePredictorFactory((ReceiveBufferSizePredictorFactory) value);
75 } else if (key.equals("receiveBufferSizePredictor")) {
76 setReceiveBufferSizePredictor((ReceiveBufferSizePredictor) value);
77 } else if (key.equals("reuseAddress")) {
78 setReuseAddress(ConversionUtil.toBoolean(value));
79 } else if (key.equals("loopbackModeDisabled")) {
80 setLoopbackModeDisabled(ConversionUtil.toBoolean(value));
81 } else if (key.equals("interface")) {
82 setInterface((InetAddress) value);
83 } else if (key.equals("networkInterface")) {
84 setNetworkInterface((NetworkInterface) value);
85 } else if (key.equals("timeToLive")) {
86 setTimeToLive(ConversionUtil.toInt(value));
87 } else if (key.equals("trafficClass")) {
88 setTrafficClass(ConversionUtil.toInt(value));
89 } else {
90 return false;
91 }
92 return true;
93 }
94
95 public boolean isBroadcast() {
96 try {
97 return socket.getBroadcast();
98 } catch (SocketException e) {
99 throw new ChannelException(e);
100 }
101 }
102
103 public void setBroadcast(boolean broadcast) {
104 try {
105 socket.setBroadcast(broadcast);
106 } catch (SocketException e) {
107 throw new ChannelException(e);
108 }
109 }
110
111 public InetAddress getInterface() {
112 if (socket instanceof MulticastSocket) {
113 try {
114 return ((MulticastSocket) socket).getInterface();
115 } catch (SocketException e) {
116 throw new ChannelException(e);
117 }
118 } else {
119 throw new UnsupportedOperationException();
120 }
121 }
122
123 public void setInterface(InetAddress interfaceAddress) {
124 if (socket instanceof MulticastSocket) {
125 try {
126 ((MulticastSocket) socket).setInterface(interfaceAddress);
127 } catch (SocketException e) {
128 throw new ChannelException(e);
129 }
130 } else {
131 throw new UnsupportedOperationException();
132 }
133 }
134
135 public boolean isLoopbackModeDisabled() {
136 if (socket instanceof MulticastSocket) {
137 try {
138 return ((MulticastSocket) socket).getLoopbackMode();
139 } catch (SocketException e) {
140 throw new ChannelException(e);
141 }
142 } else {
143 throw new UnsupportedOperationException();
144 }
145 }
146
147 public void setLoopbackModeDisabled(boolean loopbackModeDisabled) {
148 if (socket instanceof MulticastSocket) {
149 try {
150 ((MulticastSocket) socket).setLoopbackMode(loopbackModeDisabled);
151 } catch (SocketException e) {
152 throw new ChannelException(e);
153 }
154 } else {
155 throw new UnsupportedOperationException();
156 }
157 }
158
159 public NetworkInterface getNetworkInterface() {
160 if (socket instanceof MulticastSocket) {
161 try {
162 return ((MulticastSocket) socket).getNetworkInterface();
163 } catch (SocketException e) {
164 throw new ChannelException(e);
165 }
166 } else {
167 throw new UnsupportedOperationException();
168 }
169 }
170
171 public void setNetworkInterface(NetworkInterface networkInterface) {
172 if (socket instanceof MulticastSocket) {
173 try {
174 ((MulticastSocket) socket).setNetworkInterface(networkInterface);
175 } catch (SocketException e) {
176 throw new ChannelException(e);
177 }
178 } else {
179 throw new UnsupportedOperationException();
180 }
181 }
182
183 public boolean isReuseAddress() {
184 try {
185 return socket.getReuseAddress();
186 } catch (SocketException e) {
187 throw new ChannelException(e);
188 }
189 }
190
191 public void setReuseAddress(boolean reuseAddress) {
192 try {
193 socket.setReuseAddress(reuseAddress);
194 } catch (SocketException e) {
195 throw new ChannelException(e);
196 }
197 }
198
199 public int getReceiveBufferSize() {
200 try {
201 return socket.getReceiveBufferSize();
202 } catch (SocketException e) {
203 throw new ChannelException(e);
204 }
205 }
206
207 public void setReceiveBufferSize(int receiveBufferSize) {
208 try {
209 socket.setReceiveBufferSize(receiveBufferSize);
210 } catch (SocketException e) {
211 throw new ChannelException(e);
212 }
213 }
214
215 public int getSendBufferSize() {
216 try {
217 return socket.getSendBufferSize();
218 } catch (SocketException e) {
219 throw new ChannelException(e);
220 }
221 }
222
223 public void setSendBufferSize(int sendBufferSize) {
224 try {
225 socket.setSendBufferSize(sendBufferSize);
226 } catch (SocketException e) {
227 throw new ChannelException(e);
228 }
229 }
230
231 public int getTimeToLive() {
232 if (socket instanceof MulticastSocket) {
233 try {
234 return ((MulticastSocket) socket).getTimeToLive();
235 } catch (IOException e) {
236 throw new ChannelException(e);
237 }
238 } else {
239 throw new UnsupportedOperationException();
240 }
241 }
242
243 public void setTimeToLive(int ttl) {
244 if (socket instanceof MulticastSocket) {
245 try {
246 ((MulticastSocket) socket).setTimeToLive(ttl);
247 } catch (IOException e) {
248 throw new ChannelException(e);
249 }
250 } else {
251 throw new UnsupportedOperationException();
252 }
253 }
254
255 public int getTrafficClass() {
256 try {
257 return socket.getTrafficClass();
258 } catch (SocketException e) {
259 throw new ChannelException(e);
260 }
261 }
262
263 public void setTrafficClass(int trafficClass) {
264 try {
265 socket.setTrafficClass(trafficClass);
266 } catch (SocketException e) {
267 throw new ChannelException(e);
268 }
269 }
270
271 public ReceiveBufferSizePredictor getReceiveBufferSizePredictor() {
272 ReceiveBufferSizePredictor predictor = this.predictor;
273 if (predictor == null) {
274 try {
275 this.predictor = predictor = getReceiveBufferSizePredictorFactory().getPredictor();
276 } catch (Exception e) {
277 throw new ChannelException(
278 "Failed to create a new " +
279 ReceiveBufferSizePredictor.class.getSimpleName() + '.',
280 e);
281 }
282 }
283 return predictor;
284 }
285
286 public void setReceiveBufferSizePredictor(
287 ReceiveBufferSizePredictor predictor) {
288 if (predictor == null) {
289 throw new NullPointerException("predictor");
290 }
291 this.predictor = predictor;
292 }
293
294 public ReceiveBufferSizePredictorFactory getReceiveBufferSizePredictorFactory() {
295 return predictorFactory;
296 }
297
298 public void setReceiveBufferSizePredictorFactory(ReceiveBufferSizePredictorFactory predictorFactory) {
299 if (predictorFactory == null) {
300 throw new NullPointerException("predictorFactory");
301 }
302 this.predictorFactory = predictorFactory;
303 }
304 }