* because it is not compatible with this code
* @throws ClassNotFoundException
* if a class described in the serialised data cannot be found
+ * @throws IOException
+ * if the content cannot be read (for instance, corrupt data)
*/
public Importer read(String data) throws NoSuchFieldException,
- NoSuchMethodException, ClassNotFoundException {
+ NoSuchMethodException, ClassNotFoundException, IOException {
+ Scanner scan = new Scanner(data);
try {
- Scanner scan = new Scanner(data);
scan.useDelimiter("\n");
while (scan.hasNext()) {
String line = scan.next();
if (line.startsWith("ZIP:")) {
- line = StringUtils.unzip64(line.substring("ZIP:".length()));
+ try {
+ line = StringUtils.unzip64(line.substring("ZIP:"
+ .length()));
+ } catch (IOException e) {
+ throw new IOException(
+ "Internal error when decoding ZIP content: input may be corrupt");
+ }
read(line);
} else {
processLine(line);
}
}
+ } finally {
scan.close();
- } catch (IOException e) {
- throw new NoSuchMethodException(
- "Internal error when decoding ZIP content: input may be corrupt");
}
return this;
* because it is not compatible with this code
* @throws ClassNotFoundException
* if a class described in the serialised data cannot be found
+ * @throws IOException
+ * if the content cannot be read (for instance, corrupt data)
*/
private boolean processLine(String line) throws NoSuchFieldException,
- NoSuchMethodException, ClassNotFoundException {
+ NoSuchMethodException, ClassNotFoundException, IOException {
// Defer to latest child if any
if (child != null) {
if (child.processLine(line)) {
}
@Override
- protected Object fromString(String content) {
+ protected Object fromString(String content) throws IOException {
String[] tab = content.split("\n");
try {
return array;
} catch (Exception e) {
- throw new UnknownFormatConversionException(e.getMessage());
+ if (e instanceof IOException) {
+ throw (IOException) e;
+ }
+ throw new IOException(e.getMessage());
}
}
});
*
* @return the object (can be NULL for NULL encoded values)
*
- * @throws UnknownFormatConversionException
+ * @throws IOException
* if the content cannot be converted
*/
- static Object decode(String encodedValue) {
- String cut = "";
- if (encodedValue.length() > 1) {
- cut = encodedValue.substring(0, encodedValue.length() - 1);
- }
-
+ static Object decode(String encodedValue) throws IOException {
try {
+ String cut = "";
+ if (encodedValue.length() > 1) {
+ cut = encodedValue.substring(0, encodedValue.length() - 1);
+ }
+
if (CustomSerializer.isCustom(encodedValue)) {
// custom:TYPE_NAME:"content is String-encoded"
String type = CustomSerializer.typeOf(encodedValue);
if (customTypes.containsKey(type)) {
return customTypes.get(type).decode(encodedValue);
}
- throw new UnknownFormatConversionException(
- "Unknown custom type: " + type);
+ throw new IOException("Unknown custom type: " + type);
} else if (encodedValue.equals("NULL")
|| encodedValue.equals("null")) {
return null;
return Integer.parseInt(encodedValue);
}
} catch (Exception e) {
- if (e instanceof UnknownFormatConversionException) {
- throw (UnknownFormatConversionException) e;
+ if (e instanceof IOException) {
+ throw (IOException) e;
}
- throw new UnknownFormatConversionException(e.getMessage());
+ throw new IOException(e.getMessage());
}
}
package be.nikiroo.utils.serial.server;
import java.io.IOException;
+import java.lang.reflect.Array;
import java.net.Socket;
+import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.TraceHandler;
import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.Importer;
* found (which can later on be queried via
* {@link ServerBridge#getPort()}
* @param ssl
- * use a SSL connection (or not)
+ * use an SSL connection (or not)
+ * @param forwardToHost
+ * the host server to forward the calls to
+ * @param forwardToPort
+ * the host port to forward the calls to
+ * @param forwardToSsl
+ * use an SSL connection for the forward server or not
*
* @throws IOException
* in case of I/O error
* @param port
* the port to listen on
* @param ssl
- * use a SSL connection (or not)
+ * use an SSL connection (or not)
+ * @param forwardToHost
+ * the host server to forward the calls to
+ * @param forwardToPort
+ * the host port to forward the calls to
+ * @param forwardToSsl
+ * use an SSL connection for the forward server or not
*
* @throws IOException
* in case of I/O error
/**
* The traces handler for this {@link Server}.
* <p>
+ * The trace levels are handled as follow:
* <ul>
- * <li>At level 1, it will only print basic IN/OUT messages with length.</li>
- * <li>At level 2, it will also print the data as a String.</li>
- * <li>At level 3, it will try to interpret it (SLOW) and print the object
- * type if possible.</li>
- * <li>At level 4, it will try to print the {@link Object#toString()} value.
- * </li>
+ * <li>1: it will only print basic IN/OUT messages with length</li>
+ * <li>2: it will try to interpret it as an object (SLOW) and print the
+ * object class if possible</li>
+ * <li>3: it will try to print the {@link Object#toString()} value, or the
+ * data if it is not an object</li>
+ * <li>4: it will also print the unzipped serialised value if it is an
+ * object</li>
* </ul>
*
* @param tracer
*
* @param clientVersion
* the client version
- * @param data
- * the data sent by the client
*/
protected void onClientContact(Version clientVersion) {
- getTraceHandler().trace("CLIENT " + clientVersion);
+ getTraceHandler().trace("<<< CLIENT " + clientVersion);
}
/**
*
* @param serverVersion
* the server version
- * @param data
- * the data sent by the client
*/
protected void onServerContact(Version serverVersion) {
- getTraceHandler().trace("SERVER " + serverVersion);
+ getTraceHandler().trace(">>> SERVER " + serverVersion);
}
/**
* the data to trace
*/
private void trace(String prefix, String data) {
- getTraceHandler().trace(prefix + ": " + data.length() + " characters",
- 1);
+ int size = data.length();
+ String ssize = size + " byte";
+ if (size > 1) {
+ ssize = size + " bytes";
+ if (size >= 1000) {
+ size = size / 1000;
+ ssize = size + " kb";
+ if (size > 1000) {
+ size = size / 1000;
+ ssize = size + " MB";
+ }
+ }
+ }
+
+ getTraceHandler().trace(prefix + ": " + ssize, 1);
if (getTraceHandler().getTraceLevel() >= 2) {
try {
+ if (data.startsWith("ZIP:")) {
+ data = StringUtils.unzip64(data.substring(4));
+ }
+
Object obj = new Importer().read(data).getValue();
if (obj == null) {
+ getTraceHandler().trace("NULL", 2);
getTraceHandler().trace("NULL", 3);
getTraceHandler().trace("NULL", 4);
} else {
- getTraceHandler().trace("(" + obj.getClass() + ")", 3);
- getTraceHandler().trace("" + obj.toString(), 4);
+ if (obj.getClass().isArray()) {
+ getTraceHandler().trace(
+ "(" + obj.getClass() + ") with "
+ + Array.getLength(obj) + "element(s)",
+ 3);
+ } else {
+ getTraceHandler().trace("(" + obj.getClass() + ")", 2);
+ }
+ getTraceHandler().trace("" + obj.toString(), 3);
+ getTraceHandler().trace(data, 4);
}
+ } catch (NoSuchMethodException e) {
+ getTraceHandler().trace("(not an object)", 2);
+ getTraceHandler().trace(data, 3);
+ getTraceHandler().trace("", 4);
+ } catch (NoSuchFieldException e) {
+ getTraceHandler().trace(
+ "(object known but incompatible: " + e.getMessage()
+ + ")", 2);
+ getTraceHandler().trace(data, 3);
+ getTraceHandler().trace("", 4);
+ } catch (ClassNotFoundException e) {
+ getTraceHandler().trace(
+ "(unknown object: " + e.getMessage() + ")", 2);
+ getTraceHandler().trace(data, 3);
+ getTraceHandler().trace("", 4);
} catch (Exception e) {
- getTraceHandler().trace("(not an object)", 3);
- getTraceHandler().trace(data, 4);
+ getTraceHandler()
+ .trace("(error when trying to decode: "
+ + e.getMessage() + ")", 2);
+ getTraceHandler().trace(data, 3);
+ getTraceHandler().trace("", 4);
}
- getTraceHandler().trace("", 4);
+ getTraceHandler().trace("", 2);
}
}
* <ul>
* <li>The bridge name</li>
* <li>The bridge port</li>
- * <li>TRUE for a ssl bridge, FALSE for plain text</li>
+ * <li>TRUE for an SSL bridge, FALSE for plain text</li>
* <li>The forward server host</li>
* <li>The forward server port</li>
- * <li>TRUE for a ssl forward server, FALSE for plain text</li>
+ * <li>TRUE for an SSL forward server, FALSE for plain text</li>
* <li>(optional) a trace level</li>
* </ul>
*/
git://git.nikiroo.be / nikiroo-utils.git / commitdiff