void FillSerializers
(XmlNode node, SerializationConfig serializationConfig)
{
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
string value = GetTextContent(child);
if ("serializer".Equals(name))
{
var serializerConfig = new SerializerConfig();
serializerConfig.SetClassName(value);
string typeClassName = GetAttribute(child, "type-class");
serializerConfig.SetTypeClassName(typeClassName);
serializationConfig.AddSerializerConfig(serializerConfig);
}
else
{
if ("global-serializer".Equals(name))
{
var globalSerializerConfig = new GlobalSerializerConfig();
globalSerializerConfig.SetClassName(value);
serializationConfig.SetGlobalSerializerConfig(globalSerializerConfig);
}
}
}
}
public void TestAddDataSerializableFactoryClassWithDuplicateId()
{
var config = new SerializationConfig();
config.AddDataSerializableFactory(1, new MyDataSerializableFactory());
config.AddDataSerializableFactoryClass(1, typeof(MyDataSerializableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
}
public void TestAddDataSerializableFactoryClass()
{
var service1 = new SerializationServiceBuilder().Build();
var data = service1.ToData(new DataSerializableBasicType());
var config = new SerializationConfig();
config.AddDataSerializableFactoryClass(1, typeof(MyDataSerializableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
var obj = service.ToObject<object>(data);
Assert.IsInstanceOf<DataSerializableBasicType>(obj);
}
protected internal virtual SerializationConfig ParseSerialization(XmlNode node)
{
var serializationConfig = new SerializationConfig();
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
switch (name)
{
case "portable-version":
serializationConfig.SetPortableVersion(GetIntegerValue(name, GetTextContent(child), 0));
break;
case "check-class-def-errors":
serializationConfig.SetCheckClassDefErrors(CheckTrue(GetTextContent(child)));
break;
case "use-native-byte-order":
serializationConfig.SetUseNativeByteOrder(CheckTrue(GetTextContent(child)));
break;
case "byte-order":
string bigEndian = GetTextContent(child);
ByteOrder byteOrder = ByteOrder.GetByteOrder(bigEndian);
serializationConfig.SetByteOrder(byteOrder);
break;
case "enable-compression":
serializationConfig.SetEnableCompression(CheckTrue(GetTextContent(child)));
break;
case "enable-shared-object":
serializationConfig.SetEnableSharedObject(CheckTrue(GetTextContent(child)));
break;
case "data-serializable-factories":
FillDataSerializableFactories(child, serializationConfig);
break;
case "portable-factories":
FillPortableFactories(child, serializationConfig);
break;
case "serializers":
FillSerializers(child, serializationConfig);
break;
}
}
return(serializationConfig);
}
public ISerializationServiceBuilder SetConfig(SerializationConfig config)
{
_config = config;
if (_portableVersion < 0)
{
_portableVersion = config.GetPortableVersion();
}
_checkClassDefErrors = config.IsCheckClassDefErrors();
_useNativeByteOrder = config.IsUseNativeByteOrder();
_byteOrder = config.GetByteOrder();
_enableCompression = config.IsEnableCompression();
_enableSharedObject = config.IsEnableSharedObject();
return this;
}
private static void FillPortableFactories(this SerializationConfig serializationConfig, XmlNode node)
{
foreach (XmlNode child in node.ChildNodes)
{
var name = CleanNodeName(child);
if ("portable-factory".Equals(name))
{
var value = GetTextContent(child);
var factoryIdNode = child?.Attributes?.GetNamedItem("factory-id");
if (factoryIdNode == null)
{
throw new ArgumentException("'factory-id' attribute of 'portable-factory' is required!");
}
var factoryId = Convert.ToInt32(GetTextContent(factoryIdNode));
serializationConfig.PortableFactoryClasses.Add(factoryId, value);
}
}
}
protected internal virtual void FillPortableFactories(XmlNode node, SerializationConfig serializationConfig)
{
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
if ("portable-factory".Equals(name))
{
string value = GetTextContent(child);
XmlNode factoryIdNode = child.Attributes.GetNamedItem("factory-id");
if (factoryIdNode == null)
{
throw new ArgumentException("'factory-id' attribute of 'portable-factory' is required!");
}
int factoryId = Convert.ToInt32(GetTextContent(factoryIdNode));
serializationConfig.AddPortableFactoryClass(factoryId, value);
}
}
}
protected internal void FillDataSerializableFactories(XmlNode node, SerializationConfig serializationConfig)
{
foreach (XmlNode child in node.ChildNodes)
{
var name = CleanNodeName(child);
if ("data-serializable-factory".Equals(name))
{
var value = GetTextContent(child);
var factoryIdNode = child.Attributes.GetNamedItem("factory-id");
if (factoryIdNode == null)
{
throw new ArgumentException(
"'factory-id' attribute of 'data-serializable-factory' is required!");
}
var factoryId = Convert.ToInt32(GetTextContent(factoryIdNode));
serializationConfig.AddDataSerializableFactoryClass(factoryId, value);
}
}
}
void FillPortableFactories
(XmlNode node, SerializationConfig serializationConfig)
{
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
if ("portable-factory".Equals(name))
{
string value = GetTextContent(child);
XmlNode factoryIdNode = child.Attributes.GetNamedItem("factory-id");
if (factoryIdNode == null)
{
throw new ArgumentException("'factory-id' attribute of 'portable-factory' is required!");
}
int factoryId = Convert.ToInt32(GetTextContent(factoryIdNode));
serializationConfig.AddPortableFactoryClass(factoryId, value);
}
}
}
private static void HandleSerialization(this SerializationConfig serializationConfig, XmlNode node)
{
foreach (XmlNode child in node.ChildNodes)
{
var name = CleanNodeName(child);
switch (name)
{
case "portable-version":
serializationConfig.PortableVersion = GetIntegerValue(name, GetTextContent(child), 0);
break;
case "check-class-def-errors":
serializationConfig.CheckClassDefErrors = CheckTrue(GetTextContent(child));
break;
case "use-native-byte-order":
serializationConfig.UseNativeByteOrder = CheckTrue(GetTextContent(child));
break;
case "byte-order":
var bigEndian = GetTextContent(child);
var byteOrder = ByteOrder.GetByteOrder(bigEndian);
serializationConfig.ByteOrder = byteOrder;
break;
case "data-serializable-factories":
serializationConfig.FillDataSerializableFactories(child);
break;
case "portable-factories":
serializationConfig.FillPortableFactories(child);
break;
case "serializers":
serializationConfig.FillSerializers(child);
break;
default:
throw new InvalidConfigurationException($"Not supported xml tag {name}");
}
}
}
public virtual void TestInputOutputWithPortableReader(ByteOrder byteOrder)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationConfig();
config.AddPortableFactoryClass(KitchenSinkPortableFactory.FactoryId, typeof (KitchenSinkPortableFactory));
var ss = new SerializationServiceBuilder().SetConfig(config).
SetUseNativeByteOrder(false).SetByteOrder(byteOrder).Build();
var data = ss.ToData(portable);
var reader = ss.CreatePortableReader(data);
var actual = new KitchenSinkPortable();
actual.ReadPortable(reader);
Assert.AreEqual(portable, actual);
ss.Destroy();
}
public virtual void TestDataInputOutputWithPortable(ByteOrder byteOrder)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationConfig();
config.AddPortableFactoryClass(KitchenSinkPortableFactory.FactoryId, typeof (KitchenSinkPortableFactory));
var ss = new SerializationServiceBuilder().SetConfig(config).
SetUseNativeByteOrder(false).SetByteOrder(byteOrder).Build();
IObjectDataOutput output = ss.CreateObjectDataOutput(1024);
output.WriteObject(portable);
var data = output.ToByteArray();
IObjectDataInput input = ss.CreateObjectDataInput(data);
var readObject = input.ReadObject<IPortable>();
Assert.AreEqual(portable, readObject);
ss.Destroy();
}
private static void FillSerializers(this SerializationConfig serializationConfig, XmlNode node)
{
foreach (XmlNode child in node.ChildNodes)
{
var name = CleanNodeName(child);
var value = GetTextContent(child);
if ("serializer".Equals(name))
{
var serializerConfig = new SerializerConfig();
serializerConfig.SetClassName(value);
var typeClassName = GetAttribute(child, "type-class");
serializerConfig.SetTypeClassName(typeClassName);
serializationConfig.SerializerConfigs.Add(serializerConfig);
}
else
{
if ("global-serializer".Equals(name))
{
serializationConfig.ConfigureGlobalSerializer(gs => { gs.TypeName = value; });
}
}
}
}
protected internal virtual void FillSerializers(XmlNode node, SerializationConfig serializationConfig)
{
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
string value = GetTextContent(child);
if ("serializer".Equals(name))
{
var serializerConfig = new SerializerConfig();
serializerConfig.SetClassName(value);
string typeClassName = GetAttribute(child, "type-class");
serializerConfig.SetTypeClassName(typeClassName);
serializationConfig.AddSerializerConfig(serializerConfig);
}
else
{
if ("global-serializer".Equals(name))
{
var globalSerializerConfig = new GlobalSerializerConfig();
globalSerializerConfig.SetClassName(value);
serializationConfig.SetGlobalSerializerConfig(globalSerializerConfig);
}
}
}
}
public void TestWriteObjectWithCustomSerializable()
{
var config = new SerializationConfig();
var sc = new SerializerConfig()
.SetImplementation(new CustomSerializer())
.SetTypeClass(typeof (CustomSerializableType));
config.AddSerializerConfig(sc);
var serializationService =
new SerializationServiceBuilder().SetPortableVersion(1)
.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new TestPortableFactory())
.SetConfig(config).Build();
var foo = new CustomSerializableType {Value = "foo"};
var objectCarryingPortable1 = new ObjectCarryingPortable(foo);
var data = serializationService.ToData(objectCarryingPortable1);
var objectCarryingPortable2 = serializationService.ToObject<ObjectCarryingPortable>(data);
Assert.AreEqual(objectCarryingPortable1, objectCarryingPortable2);
}
public void TestClassDefinitionConfigWithErrors()
{
var serializationConfig = new SerializationConfig();
serializationConfig.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID,
new TestPortableFactory());
serializationConfig.SetPortableVersion(1);
serializationConfig.AddClassDefinition(
new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID,
TestSerializationConstants.RAW_DATA_PORTABLE)
.AddLongField("l")
.AddCharArrayField("c")
.AddPortableField("p", CreateNamedPortableClassDefinition())
.Build());
try
{
new SerializationServiceBuilder().SetConfig(serializationConfig).Build();
Assert.Fail("Should throw HazelcastSerializationException!");
}
catch (HazelcastSerializationException)
{
}
new SerializationServiceBuilder().SetConfig(serializationConfig).SetCheckClassDefErrors(false).Build();
// -- OR --
serializationConfig.SetCheckClassDefErrors(false);
new SerializationServiceBuilder().SetConfig(serializationConfig).Build();
}
public void TestClassDefinitionConfig()
{
var serializationConfig = new SerializationConfig();
serializationConfig.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID,
new TestPortableFactory());
serializationConfig.SetPortableVersion(1);
serializationConfig
.AddClassDefinition(
new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID,
TestSerializationConstants.RAW_DATA_PORTABLE)
.AddLongField("l")
.AddCharArrayField("c")
.AddPortableField("p", CreateNamedPortableClassDefinition())
.Build())
.AddClassDefinition(
new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID,
TestSerializationConstants.NAMED_PORTABLE)
.AddUTFField("name").AddIntField("myint").Build());
var serializationService = new SerializationServiceBuilder()
.SetConfig(serializationConfig)
.AddDataSerializableFactory(TestSerializationConstants.DATA_SERIALIZABLE_FACTORY_ID,
GetDataSerializableFactory())
.Build();
var p = new RawDataPortable(DateTime.Now.ToFileTime(), "test chars".ToCharArray(),
new NamedPortable("named portable", 34567),
9876, "Testing raw portable", new ByteArrayDataSerializable(Encoding.UTF8.GetBytes("test bytes")));
var data = serializationService.ToData(p);
Assert.AreEqual(p, serializationService.ToObject<RawDataPortable>(data));
}
private void HandleSerialization(XmlNode node)
{
SerializationConfig serializationConfig = ParseSerialization(node);
clientConfig.SetSerializationConfig(serializationConfig);
}
public void TestAddPortableFactoryWithDuplicateId()
{
var config = new SerializationConfig();
config.AddPortableFactory(1, new KitchenSinkPortableFactory());
var service = new SerializationServiceBuilder().AddPortableFactory(1,
new KitchenSinkPortableFactory()).SetConfig(config).Build();
}
public virtual ClientConfig SetSerializationConfig(SerializationConfig serializationConfig)
{
_serializationConfig = serializationConfig;
return(this);
}
public void TestAddDataSerializableFactoryWithBadId()
{
var config = new SerializationConfig();
config.AddDataSerializableFactory(-1, new MyDataSerializableFactory());
var service = new SerializationServiceBuilder().SetConfig(config).Build();
}
private void AddConfigPortableFactories(IDictionary<int, IPortableFactory> portableFactories,
SerializationConfig config)
{
foreach (var entry in config.GetPortableFactories())
{
int factoryId = entry.Key;
IPortableFactory factory = entry.Value;
if (factoryId <= 0)
{
throw new ArgumentException("IPortableFactory factoryId must be positive! -> " + factory);
}
if (portableFactories.ContainsKey(factoryId))
{
throw new ArgumentException("IPortableFactory with factoryId '" + factoryId +
"' is already registered!");
}
portableFactories.Add(factoryId, factory);
}
foreach (var entry in config.GetPortableFactoryClasses())
{
int factoryId = entry.Key;
string factoryClassName = entry.Value;
if (factoryId <= 0)
{
throw new ArgumentException("IPortableFactory factoryId must be positive! -> " + factoryClassName);
}
if (portableFactories.ContainsKey(factoryId))
{
throw new ArgumentException("IPortableFactory with factoryId '" + factoryId +
"' is already registered!");
}
var type = Type.GetType(factoryClassName);
if (type == null)
{
throw new HazelcastSerializationException("Unable to find type " + factoryClassName);
}
if (!typeof (IPortableFactory).IsAssignableFrom(type))
{
throw new HazelcastSerializationException("Type " + type + " does not implement IPortableFactory");
}
var factory = Activator.CreateInstance(type) as IPortableFactory;
portableFactories.Add(factoryId, factory);
}
foreach (IPortableFactory f in portableFactories.Values)
{
if (f is IHazelcastInstanceAware)
{
((IHazelcastInstanceAware)f).SetHazelcastInstance(_hazelcastInstance);
}
}
}
public void TestAddPortableFactoryClass()
{
var service1 = new SerializationServiceBuilder().Build();
var data = service1.ToData(new KitchenSinkPortable());
var config = new SerializationConfig();
config.AddPortableFactoryClass(1, typeof(KitchenSinkPortableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
var obj = service.ToObject<object>(data);
Assert.IsInstanceOf<KitchenSinkPortable>(obj);
}
public void TestAddPortableFactoryClassWhichDoesNotImplementPortableFactory()
{
var config = new SerializationConfig();
config.AddPortableFactoryClass(1, typeof(SerializableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
}
protected internal virtual SerializationConfig ParseSerialization(XmlNode node)
{
var serializationConfig = new SerializationConfig();
foreach (XmlNode child in node.ChildNodes)
{
string name = CleanNodeName(child);
switch (name)
{
case "portable-version":
serializationConfig.SetPortableVersion(GetIntegerValue(name, GetTextContent(child), 0));
break;
case "check-class-def-errors":
serializationConfig.SetCheckClassDefErrors(CheckTrue(GetTextContent(child)));
break;
case "use-native-byte-order":
serializationConfig.SetUseNativeByteOrder(CheckTrue(GetTextContent(child)));
break;
case "byte-order":
string bigEndian = GetTextContent(child);
ByteOrder byteOrder = ByteOrder.GetByteOrder(bigEndian);
serializationConfig.SetByteOrder(byteOrder);
break;
case "enable-compression":
serializationConfig.SetEnableCompression(CheckTrue(GetTextContent(child)));
break;
case "enable-shared-object":
serializationConfig.SetEnableSharedObject(CheckTrue(GetTextContent(child)));
break;
case "data-serializable-factories":
FillDataSerializableFactories(child, serializationConfig);
break;
case "portable-factories":
FillPortableFactories(child, serializationConfig);
break;
case "serializers":
FillSerializers(child, serializationConfig);
break;
}
}
return serializationConfig;
}
private void AddConfigDataSerializableFactories(
IDictionary<int, IDataSerializableFactory> dataSerializableFactories, SerializationConfig config)
{
foreach (var entry in config.GetDataSerializableFactories())
{
int factoryId = entry.Key;
IDataSerializableFactory factory = entry.Value;
if (factoryId <= 0)
{
throw new ArgumentException("IDataSerializableFactory factoryId must be positive! -> " + factory);
}
if (dataSerializableFactories.ContainsKey(factoryId))
{
throw new ArgumentException("IDataSerializableFactory with factoryId '" + factoryId +
"' is already registered!");
}
dataSerializableFactories.Add(factoryId, factory);
}
foreach (var entry in config.GetDataSerializableFactoryClasses())
{
int factoryId = entry.Key;
string factoryClassName = entry.Value;
if (factoryId <= 0)
{
throw new ArgumentException("IDataSerializableFactory factoryId must be positive! -> " +
factoryClassName);
}
if (dataSerializableFactories.ContainsKey(factoryId))
{
throw new ArgumentException("IDataSerializableFactory with factoryId '" + factoryId +
"' is already registered!");
}
IDataSerializableFactory factory = null;
try
{
Type type = Type.GetType(factoryClassName);
if (type != null)
{
factory = Activator.CreateInstance(type) as IDataSerializableFactory;
}
}
catch (Exception e)
{
//ClassLoaderUtil.newInstance(cl, factoryClassName);
throw new HazelcastSerializationException(e);
}
dataSerializableFactories.Add(factoryId, factory);
}
foreach (IDataSerializableFactory f in dataSerializableFactories.Values)
{
var aware = f as IHazelcastInstanceAware;
if (aware != null)
{
aware.SetHazelcastInstance(_hazelcastInstance);
}
}
}
public void TestAddDataSerializableFactoryClassWithNoEmptyConstructor()
{
var config = new SerializationConfig();
config.AddDataSerializableFactoryClass(1, typeof(SerializableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
}
public void TestAddPortableFactoryClassWithBadId()
{
var config = new SerializationConfig();
config.AddPortableFactoryClass(-1, typeof(KitchenSinkPortableFactory));
var service = new SerializationServiceBuilder().SetConfig(config).Build();
}
