1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.jetty.websocket.jsr356;
20
21 import java.io.IOException;
22 import java.nio.ByteBuffer;
23 import java.util.concurrent.Future;
24
25 import javax.websocket.EncodeException;
26 import javax.websocket.Encoder;
27 import javax.websocket.RemoteEndpoint;
28 import javax.websocket.SendHandler;
29 import javax.websocket.SendResult;
30
31 import org.eclipse.jetty.util.BufferUtil;
32 import org.eclipse.jetty.util.log.Log;
33 import org.eclipse.jetty.util.log.Logger;
34 import org.eclipse.jetty.websocket.common.WebSocketFrame;
35 import org.eclipse.jetty.websocket.common.frames.BinaryFrame;
36 import org.eclipse.jetty.websocket.common.frames.TextFrame;
37 import org.eclipse.jetty.websocket.common.message.MessageOutputStream;
38 import org.eclipse.jetty.websocket.common.message.MessageWriter;
39 import org.eclipse.jetty.websocket.common.util.TextUtil;
40 import org.eclipse.jetty.websocket.jsr356.messages.SendHandlerWriteCallback;
41
42 public class JsrAsyncRemote extends AbstractJsrRemote implements RemoteEndpoint.Async
43 {
44 static final Logger LOG = Log.getLogger(JsrAsyncRemote.class);
45
46 protected JsrAsyncRemote(JsrSession session)
47 {
48 super(session);
49 }
50
51 @Override
52 public long getSendTimeout()
53 {
54
55 return 0;
56 }
57
58 @Override
59 public Future<Void> sendBinary(ByteBuffer data)
60 {
61 assertMessageNotNull(data);
62 if (LOG.isDebugEnabled())
63 {
64 LOG.debug("sendBinary({})",BufferUtil.toDetailString(data));
65 }
66 return jettyRemote.sendBytesByFuture(data);
67 }
68
69 @Override
70 public void sendBinary(ByteBuffer data, SendHandler handler)
71 {
72 assertMessageNotNull(data);
73 assertSendHandlerNotNull(handler);
74 if (LOG.isDebugEnabled())
75 {
76 LOG.debug("sendBinary({},{})",BufferUtil.toDetailString(data),handler);
77 }
78 WebSocketFrame frame = new BinaryFrame().setPayload(data).setFin(true);
79 jettyRemote.uncheckedSendFrame(frame,new SendHandlerWriteCallback(handler));
80 }
81
82 @Override
83 public Future<Void> sendObject(Object data)
84 {
85 return sendObjectViaFuture(data);
86 }
87
88 @SuppressWarnings(
89 { "rawtypes", "unchecked" })
90 @Override
91 public void sendObject(Object data, SendHandler handler)
92 {
93 assertMessageNotNull(data);
94 assertSendHandlerNotNull(handler);
95 if (LOG.isDebugEnabled())
96 {
97 LOG.debug("sendObject({},{})",data,handler);
98 }
99
100 Encoder encoder = encoders.getEncoderFor(data.getClass());
101 if (encoder == null)
102 {
103 throw new IllegalArgumentException("No encoder for type: " + data.getClass());
104 }
105
106 if (encoder instanceof Encoder.Text)
107 {
108 Encoder.Text etxt = (Encoder.Text)encoder;
109 try
110 {
111 String msg = etxt.encode(data);
112 sendText(msg,handler);
113 return;
114 }
115 catch (EncodeException e)
116 {
117 handler.onResult(new SendResult(e));
118 }
119 }
120 else if (encoder instanceof Encoder.TextStream)
121 {
122 Encoder.TextStream etxt = (Encoder.TextStream)encoder;
123 SendHandlerWriteCallback callback = new SendHandlerWriteCallback(handler);
124 try (MessageWriter writer = new MessageWriter(session))
125 {
126 writer.setCallback(callback);
127 etxt.encode(data,writer);
128 return;
129 }
130 catch (EncodeException | IOException e)
131 {
132 handler.onResult(new SendResult(e));
133 }
134 }
135 else if (encoder instanceof Encoder.Binary)
136 {
137 Encoder.Binary ebin = (Encoder.Binary)encoder;
138 try
139 {
140 ByteBuffer buf = ebin.encode(data);
141 sendBinary(buf,handler);
142 return;
143 }
144 catch (EncodeException e)
145 {
146 handler.onResult(new SendResult(e));
147 }
148 }
149 else if (encoder instanceof Encoder.BinaryStream)
150 {
151 Encoder.BinaryStream ebin = (Encoder.BinaryStream)encoder;
152 SendHandlerWriteCallback callback = new SendHandlerWriteCallback(handler);
153 try (MessageOutputStream out = new MessageOutputStream(session))
154 {
155 out.setCallback(callback);
156 ebin.encode(data,out);
157 return;
158 }
159 catch (EncodeException | IOException e)
160 {
161 handler.onResult(new SendResult(e));
162 }
163 }
164
165 throw new IllegalArgumentException("Unknown encoder type: " + encoder);
166 }
167
168 @Override
169 public Future<Void> sendText(String text)
170 {
171 assertMessageNotNull(text);
172 if (LOG.isDebugEnabled())
173 {
174 LOG.debug("sendText({})",TextUtil.hint(text));
175 }
176 return jettyRemote.sendStringByFuture(text);
177 }
178
179 @Override
180 public void sendText(String text, SendHandler handler)
181 {
182 assertMessageNotNull(text);
183 assertSendHandlerNotNull(handler);
184 if (LOG.isDebugEnabled())
185 {
186 LOG.debug("sendText({},{})",TextUtil.hint(text),handler);
187 }
188 WebSocketFrame frame = new TextFrame().setPayload(text).setFin(true);
189 jettyRemote.uncheckedSendFrame(frame,new SendHandlerWriteCallback(handler));
190 }
191
192 @Override
193 public void setSendTimeout(long timeoutmillis)
194 {
195
196 }
197 }