fix bad import
[nikiroo-utils.git] / src / be / nikiroo / utils / serial / server / ServerBridge.java
... / ...
CommitLineData
1package be.nikiroo.utils.serial.server;
2
3import java.io.ByteArrayInputStream;
4import java.io.IOException;
5import java.io.InputStream;
6import java.lang.reflect.Array;
7import java.net.Socket;
8import java.net.UnknownHostException;
9
10import be.nikiroo.utils.StringUtils;
11import be.nikiroo.utils.TraceHandler;
12import be.nikiroo.utils.Version;
13import be.nikiroo.utils.serial.Importer;
14
15/**
16 * This class implements a simple server that can bridge two other
17 * {@link Server}s.
18 * <p>
19 * It can, of course, inspect the data that goes through it (by default, it
20 * prints traces of the data).
21 * <p>
22 * Note: this {@link ServerBridge} has to be discarded after use (cannot be
23 * started twice).
24 *
25 * @author niki
26 */
27public class ServerBridge extends Server {
28 private final String forwardToHost;
29 private final int forwardToPort;
30 private final String forwardToKey;
31
32 /**
33 * Create a new server that will start listening on the network when
34 * {@link ServerBridge#start()} is called.
35 *
36 * @param port
37 * the port to listen on, or 0 to assign any unallocated port
38 * found (which can later on be queried via
39 * {@link ServerBridge#getPort()}
40 * @param key
41 * an optional key to encrypt all the communications (if NULL,
42 * everything will be sent in clear text)
43 * @param forwardToHost
44 * the host server to forward the calls to
45 * @param forwardToPort
46 * the host port to forward the calls to
47 * @param forwardToKey
48 * an optional key to encrypt all the communications (if NULL,
49 * everything will be sent in clear text)
50 *
51 * @throws IOException
52 * in case of I/O error
53 * @throws UnknownHostException
54 * if the IP address of the host could not be determined
55 * @throws IllegalArgumentException
56 * if the port parameter is outside the specified range of valid
57 * port values, which is between 0 and 65535, inclusive
58 */
59 public ServerBridge(int port, String key, String forwardToHost,
60 int forwardToPort, String forwardToKey) throws IOException {
61 super(port, key);
62 this.forwardToHost = forwardToHost;
63 this.forwardToPort = forwardToPort;
64 this.forwardToKey = forwardToKey;
65 }
66
67 /**
68 * Create a new server that will start listening on the network when
69 * {@link ServerBridge#start()} is called.
70 *
71 * @param name
72 * the server name (only used for debug info and traces)
73 * @param port
74 * the port to listen on
75 * @param key
76 * an optional key to encrypt all the communications (if NULL,
77 * everything will be sent in clear text)
78 * @param forwardToHost
79 * the host server to forward the calls to
80 * @param forwardToPort
81 * the host port to forward the calls to
82 * @param forwardToKey
83 * an optional key to encrypt all the communications (if NULL,
84 * everything will be sent in clear text) use an SSL connection
85 * for the forward server or not
86 *
87 * @throws IOException
88 * in case of I/O error
89 * @throws UnknownHostException
90 * if the IP address of the host could not be determined
91 * @throws IllegalArgumentException
92 * if the port parameter is outside the specified range of valid
93 * port values, which is between 0 and 65535, inclusive
94 */
95 public ServerBridge(String name, int port, String key,
96 String forwardToHost, int forwardToPort, String forwardToKey)
97 throws IOException {
98 super(name, port, key);
99 this.forwardToHost = forwardToHost;
100 this.forwardToPort = forwardToPort;
101 this.forwardToKey = forwardToKey;
102 }
103
104 /**
105 * The traces handler for this {@link Server}.
106 * <p>
107 * The trace levels are handled as follow:
108 * <ul>
109 * <li>1: it will only print basic IN/OUT messages with length</li>
110 * <li>2: it will try to interpret it as an object (SLOW) and print the
111 * object class if possible</li>
112 * <li>3: it will try to print the {@link Object#toString()} value, or the
113 * data if it is not an object</li>
114 * <li>4: it will also print the unzipped serialised value if it is an
115 * object</li>
116 * </ul>
117 *
118 * @param tracer
119 * the new traces handler
120 */
121 @Override
122 public void setTraceHandler(TraceHandler tracer) {
123 super.setTraceHandler(tracer);
124 }
125
126 @Override
127 protected ConnectActionServer createConnectActionServer(Socket s) {
128 // Bad impl, not up to date (should work, but not efficient)
129 return new ConnectActionServerString(s, key) {
130 @Override
131 public void action(Version clientVersion) throws Exception {
132 onClientContact(clientVersion);
133 final ConnectActionServerString bridge = this;
134
135 try {
136 new ConnectActionClientString(forwardToHost, forwardToPort,
137 forwardToKey) {
138 @Override
139 public void action(Version serverVersion)
140 throws Exception {
141 onServerContact(serverVersion);
142
143 for (String fromClient = bridge.rec(); fromClient != null; fromClient = bridge
144 .rec()) {
145 onRec(fromClient);
146 String fromServer = send(fromClient);
147 onSend(fromServer);
148 bridge.send(fromServer);
149 }
150
151 getTraceHandler().trace("=== DONE", 1);
152 getTraceHandler().trace("", 1);
153 }
154
155 @Override
156 protected void onError(Exception e) {
157 ServerBridge.this.onError(e);
158 }
159 }.connect();
160 } catch (Exception e) {
161 ServerBridge.this.onError(e);
162 }
163 }
164 };
165 }
166
167 /**
168 * This is the method that is called each time a client contact us.
169 */
170 protected void onClientContact(Version clientVersion) {
171 getTraceHandler().trace(">>> CLIENT " + clientVersion);
172 }
173
174 /**
175 * This is the method that is called each time a client contact us.
176 */
177 protected void onServerContact(Version serverVersion) {
178 getTraceHandler().trace("<<< SERVER " + serverVersion);
179 getTraceHandler().trace("");
180 }
181
182 /**
183 * This is the method that is called each time a client contact us.
184 *
185 * @param data
186 * the data sent by the client
187 */
188 protected void onRec(String data) {
189 trace(">>> CLIENT", data);
190 }
191
192 /**
193 * This is the method that is called each time the forwarded server contact
194 * us.
195 *
196 * @param data
197 * the data sent by the client
198 */
199 protected void onSend(String data) {
200 trace("<<< SERVER", data);
201 }
202
203 @Override
204 protected ConnectActionClient getConnectionToMe()
205 throws UnknownHostException, IOException {
206 return new ConnectActionClientString(new Socket((String) null,
207 getPort()), key);
208 }
209
210 @Override
211 public void run() {
212 getTraceHandler().trace(
213 getName() + ": will forward to " + forwardToHost + ":"
214 + forwardToPort + " ("
215 + (forwardToKey != null ? "encrypted" : "plain text")
216 + ")");
217 super.run();
218 }
219
220 /**
221 * Trace the data with the given prefix.
222 *
223 * @param prefix
224 * the prefix (client, server, version...)
225 * @param data
226 * the data to trace
227 */
228 private void trace(String prefix, String data) {
229 int size = data == null ? 0 : data.length();
230 String ssize = StringUtils.formatNumber(size) + "bytes";
231
232 getTraceHandler().trace(prefix + ": " + ssize, 1);
233
234 if (getTraceHandler().getTraceLevel() >= 2) {
235 try {
236 while (data.startsWith("ZIP:") || data.startsWith("B64:")) {
237 if (data.startsWith("ZIP:")) {
238 data = StringUtils.unzip64s(data.substring(4));
239 } else if (data.startsWith("B64:")) {
240 data = StringUtils.unzip64s(data.substring(4));
241 }
242 }
243
244 InputStream stream = new ByteArrayInputStream(
245 StringUtils.getBytes(data));
246 try {
247 Object obj = new Importer().read(stream).getValue();
248 if (obj == null) {
249 getTraceHandler().trace("NULL", 2);
250 getTraceHandler().trace("NULL", 3);
251 getTraceHandler().trace("NULL", 4);
252 } else {
253 if (obj.getClass().isArray()) {
254 getTraceHandler().trace(
255 "(" + obj.getClass() + ") with "
256 + Array.getLength(obj)
257 + "element(s)", 3);
258 } else {
259 getTraceHandler().trace("(" + obj.getClass() + ")",
260 2);
261 }
262 getTraceHandler().trace("" + obj.toString(), 3);
263 getTraceHandler().trace(data, 4);
264 }
265 } finally {
266 stream.close();
267 }
268 } catch (NoSuchMethodException e) {
269 getTraceHandler().trace("(not an object)", 2);
270 getTraceHandler().trace(data, 3);
271 getTraceHandler().trace("", 4);
272 } catch (NoSuchFieldException e) {
273 getTraceHandler().trace(
274 "(incompatible: " + e.getMessage() + ")", 2);
275 getTraceHandler().trace(data, 3);
276 getTraceHandler().trace("", 4);
277 } catch (ClassNotFoundException e) {
278 getTraceHandler().trace(
279 "(unknown object: " + e.getMessage() + ")", 2);
280 getTraceHandler().trace(data, 3);
281 getTraceHandler().trace("", 4);
282 } catch (Exception e) {
283 getTraceHandler().trace(
284 "(decode error: " + e.getMessage() + ")", 2);
285 getTraceHandler().trace(data, 3);
286 getTraceHandler().trace("", 4);
287 }
288
289 getTraceHandler().trace("", 2);
290 }
291 }
292}