/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.user.server.rpc;
import com.google.gwt.user.server.rpc.impl.StandardSerializationPolicy;
import com.google.gwt.user.server.rpc.impl.TypeNameObfuscator;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* API for loading a {@link SerializationPolicy}.
*/
public final class SerializationPolicyLoader {
/**
* Keyword for listing the serializable fields of an enchanced class that are
* visible to client code.
*/
public static final String CLIENT_FIELDS_KEYWORD = "@ClientFields";
/**
* Default encoding for serialization policy files.
*/
public static final String SERIALIZATION_POLICY_FILE_ENCODING = "UTF-8";
private static final String FORMAT_ERROR_MESSAGE = "Expected: className, "
+ "[true | false], [true | false], [true | false], [true | false], typeId, signature";
/**
* Returns the serialization policy file name from the serialization
* policy strong name.
*
* @param serializationPolicyStrongName the serialization policy strong name
* @return the serialization policy file name from the serialization
* policy strong name
*/
public static String getSerializationPolicyFileName(
String serializationPolicyStrongName) {
return serializationPolicyStrongName + ".gwt.rpc";
}
/**
* Loads a SerializationPolicy from an input stream.
*
* @param inputStream stream to load from
* @return a {@link SerializationPolicy} loaded from the input stream
*
* @throws IOException if an error occurs while reading the stream
* @throws ParseException if the input stream is not properly formatted
* @throws ClassNotFoundException if a class specified in the serialization
* policy cannot be loaded
*
* @deprecated see {@link #loadFromStream(InputStream, List)}
*/
@Deprecated
public static SerializationPolicy loadFromStream(InputStream inputStream)
throws IOException, ParseException, ClassNotFoundException {
List<ClassNotFoundException> classNotFoundExceptions = new ArrayList<ClassNotFoundException>();
SerializationPolicy serializationPolicy = loadFromStream(inputStream,
classNotFoundExceptions);
if (!classNotFoundExceptions.isEmpty()) {
// Just report the first failure.
throw classNotFoundExceptions.get(0);
}
return serializationPolicy;
}
/**
* Loads a SerializationPolicy from an input stream and optionally record any
* {@link ClassNotFoundException}s.
*
* @param inputStream stream to load the SerializationPolicy from.
* @param classNotFoundExceptions if not <code>null</code>, all of the
* {@link ClassNotFoundException}s thrown while loading this
* serialization policy will be added to this list
* @return a {@link SerializationPolicy} loaded from the input stream.
*
* @throws IOException if an error occurs while reading the stream
* @throws ParseException if the input stream is not properly formatted
*/
public static SerializationPolicy loadFromStream(InputStream inputStream,
List<ClassNotFoundException> classNotFoundExceptions) throws IOException,
ParseException {
if (inputStream == null) {
throw new NullPointerException("inputStream");
}
Map<Class<?>, Boolean> whitelistSer = new HashMap<Class<?>, Boolean>();
Map<Class<?>, Boolean> whitelistDeser = new HashMap<Class<?>, Boolean>();
Map<Class<?>, String> typeIds = new HashMap<Class<?>, String>();
Map<Class<?>, Set<String>> clientFields = new HashMap<Class<?>, Set<String>>();
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
InputStreamReader isr = new InputStreamReader(inputStream,
SERIALIZATION_POLICY_FILE_ENCODING);
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
int lineNum = 1;
while (line != null) {
line = line.trim();
if (line.length() > 0) {
String[] components = line.split(",");
if (components[0].equals(CLIENT_FIELDS_KEYWORD)) {
/*
* Lines starting with '@ClientFields' list potentially serializable fields known to
* client code for classes that may be enhanced with additional fields on the server.
* If additional server fields are found, they will be serizalized separately from the
* normal RPC process and transmitted to the client as an opaque blob of data stored
* in a WeakMapping associated with the object instance.
*/
String binaryTypeName = components[1].trim();
Class<?> clazz;
try {
clazz = Class.forName(binaryTypeName, false, contextClassLoader);
HashSet<String> fieldNames = new HashSet<String>();
for (int i = 2; i < components.length; i++) {
fieldNames.add(components[i]);
}
clientFields.put(clazz, fieldNames);
} catch (ClassNotFoundException ex) {
// Ignore the error, but add it to the list of errors if one was
// provided.
if (classNotFoundExceptions != null) {
classNotFoundExceptions.add(ex);
}
}
} else {
if (components.length != 2 && components.length != 7) {
throw new ParseException(FORMAT_ERROR_MESSAGE, lineNum);
}
for (int i = 0; i < components.length; i++) {
components[i] = components[i].trim();
if (components[i].length() == 0) {
throw new ParseException(FORMAT_ERROR_MESSAGE, lineNum);
}
}
String binaryTypeName = components[0].trim();
boolean fieldSer;
boolean instantSer;
boolean fieldDeser;
boolean instantDeser;
String typeId;
if (components.length == 2) {
fieldSer = fieldDeser = true;
instantSer = instantDeser = Boolean.valueOf(components[1]);
typeId = binaryTypeName;
} else {
int idx = 1;
// TODO: Validate the instantiable string better.
fieldSer = Boolean.valueOf(components[idx++]);
instantSer = Boolean.valueOf(components[idx++]);
fieldDeser = Boolean.valueOf(components[idx++]);
instantDeser = Boolean.valueOf(components[idx++]);
typeId = components[idx++];
if (!fieldSer && !fieldDeser
&& !TypeNameObfuscator.SERVICE_INTERFACE_ID.equals(typeId)) {
throw new ParseException("Type " + binaryTypeName
+ " is neither field serializable, field deserializable "
+ "nor the service interface", lineNum);
}
}
try {
Class<?> clazz = Class.forName(binaryTypeName, false,
contextClassLoader);
if (fieldSer) {
whitelistSer.put(clazz, instantSer);
}
if (fieldDeser) {
whitelistDeser.put(clazz, instantDeser);
}
typeIds.put(clazz, typeId);
} catch (ClassNotFoundException ex) {
// Ignore the error, but add it to the list of errors if one was
// provided.
if (classNotFoundExceptions != null) {
classNotFoundExceptions.add(ex);
}
}
}
}
line = br.readLine();
lineNum++;
}
return new StandardSerializationPolicy(whitelistSer, whitelistDeser,
typeIds, clientFields);
}
private SerializationPolicyLoader() {
}
}