public void CheckAssemblyNameAfterDeserialization()
{
ser.Serialize(dtg);
AssemblyDTG tmp = ser.Deserialize();
Assert.AreEqual(tmp.Name, "TPA.ApplicationArchitecture.dll");
}
public void Publish(object o)
{
var route = _routes.OutboundEvents.Single(c => c.MessageType == o.GetType());
var task = _outbound.ProduceAsync(route.Name, null, _encoding.GetString(_serializer.Serialize(o)));
task.RunSynchronously();
var result = task.Result;
}
public string[] Persist <TFormat>(
ISerialization <TFormat> serializer,
IServiceProvider locator,
TFormat toInsert,
TFormat toUpdate,
TFormat toDelete)
{
var repository = locator.Resolve <IPersistableRepository <TRoot> >();
var insertData = toInsert != null?serializer.Deserialize <TFormat, TRoot[]>(toInsert, locator) : null;
var updateData = toUpdate != null?serializer.Deserialize <TFormat, KeyValuePair <TRoot, TRoot>[]>(toUpdate, locator) : null;
//TODO support old update format
if (toUpdate != null && updateData != null && updateData.Length == 0)
{
var updateValues = serializer.Deserialize <TFormat, TRoot[]>(toUpdate, locator);
if (updateValues != null && updateValues.Length > 0)
{
updateData = updateValues.Select(it => new KeyValuePair <TRoot, TRoot>(default(TRoot), it)).ToArray();
}
}
var deleteData = toDelete != null?serializer.Deserialize <TFormat, TRoot[]>(toDelete, locator) : null;
if ((insertData == null || insertData.Length == 0) &&
(updateData == null || updateData.Length == 0) &&
(deleteData == null || deleteData.Length == 0))
{
throw new ArgumentException(
"Data not sent or deserialized unsuccessfully.",
new FrameworkException(@"Example:
" + serializer.Serialize(
new Argument <TFormat>
{
RootName = typeof(TRoot).FullName,
ToInsert = serializer.Serialize(new TRoot[] { new TRoot() })
})));
}
try
{
return(repository.Persist(insertData, updateData, deleteData));
}
catch (FrameworkException ex)
{
throw new ArgumentException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ArgumentException(
"Error persisting: {0}.".With(ex.Message),
new FrameworkException(
@"{0}{1}{2}".With(
FormatData(serializer, "Insert", insertData),
FormatData(serializer, "Update", updateData),
FormatData(serializer, "Delete", deleteData)),
ex));
}
}
public async Task <HttpResponseMessage> PutAsync <T>(Uri requestUri, T payload) where T : class
{
var requestMessage = new HttpRequestMessage(HttpMethod.Put, requestUri);
var content = new StringContent(serialization.Serialize(payload));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
requestMessage.Content = content;
return(await MakeRequestAsync(requestMessage));
}
public TOutput Submit <TInput, TOutput>(
ISerialization <TInput> input,
ISerialization <TOutput> output,
IServiceProvider locator,
bool returnInstance,
TInput data)
{
TEvent domainEvent;
try
{
domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>();
}
catch (Exception ex)
{
throw new ArgumentException("Error deserializing domain event.", ex);
}
var domainStore = locator.Resolve <IEventStore>();
string uri;
try
{
uri = domainStore.Submit(domainEvent);
}
catch (SecurityException) { throw; }
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
data == null
? new FrameworkException("Error while submitting event: {0}. Data not sent.".With(ex.Message), ex)
: new FrameworkException(@"Error while submitting event: {0}. Sent data:
{1}".With(ex.Message, input.Serialize(domainEvent)), ex));
}
try
{
if (returnInstance)
{
return(output.Serialize(domainEvent));
}
else
{
return(output.Serialize(uri));
}
}
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
new FrameworkException(@"Error serializing result: " + ex.Message, ex));
}
}
private static TOutput Serialize <TOutput>(ISerialization <TOutput> serializer, Stream stream)
{
if (typeof(TOutput) == typeof(object))
{
return(serializer.Serialize(stream));
}
using (var ms = new MemoryStream())
{
stream.CopyTo(ms);
stream.Dispose();
return(serializer.Serialize(ms.ToArray()));
}
}
public TOutput Update <TInput, TOutput>(
ISerialization <TInput> input,
ISerialization <TOutput> output,
IServiceProvider locator,
string uri,
bool returnInstance,
TInput data)
{
TRoot root;
try
{
root = input.Deserialize <TInput, TRoot>(data, locator);
}
catch (Exception ex)
{
throw new ArgumentException(
"Error deserializing: {0}".With(ex.Message),
new FrameworkException(@"Sent data:
{0}".With(data), ex));
}
try
{
var repository = locator.Resolve <IPersistableRepository <TRoot> >();
var original = repository.Find(uri);
if (original == null)
{
throw new ArgumentException("Can't find {0} with uri: {1}.".With(typeof(TRoot).FullName, uri));
}
repository.Persist(null, new[] { new KeyValuePair <TRoot, TRoot>(original, root) }, null);
return(returnInstance ? output.Serialize(root) : output.Serialize(root.URI));
}
catch (Exception ex)
{
string additionalInfo;
try
{
additionalInfo = @"Sent data:
" + input.Serialize(root);
}
catch (Exception sex)
{
additionalInfo = "Error serializing input: " + sex.Message;
}
throw new ArgumentException(
"Error saving: {0}.".With(ex.Message),
new FrameworkException(additionalInfo, ex));
}
}
public async void SaveAll()
{
var dataToSave = PlayerDetailsCache.Select(playerDetails =>
{
var details = new PlayerDetailsDto
{
Handicap101 = playerDetails.Handicap101,
Handicap201 = playerDetails.Handicap201,
Handicap301 = playerDetails.Handicap301,
Handicap401 = playerDetails.Handicap401,
Handicap501 = playerDetails.Handicap501,
HandicapCricket = playerDetails.HandicapCricket,
Name = playerDetails.Name,
NickName = playerDetails.NickName,
Id = playerDetails.Id
};
var definition = new ImageDefinitionDto
{
Name = playerDetails.PlayerImageDefinition.Name,
SourceBytes = playerDetails.PlayerImageDefinition.SourceBytes
};
details.PlayerImageDefinition = definition;
details.SelectedFlight = playerDetails.SelectedFlight;
return(details);
}).ToList();
await _playerSerialiser.Serialize(dataToSave);
}
public ICommandResult <TOutput> Execute <TInput, TOutput>(
IServiceProvider locator,
ISerialization <TInput> input,
ISerialization <TOutput> output,
IPrincipal principal,
TInput data)
{
var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);
if (either.Error != null)
{
return(either.Error);
}
try
{
var command = PrepareCommand(principal, either.Argument.Name, either.Argument.SpecificationName);
var exists = command.CheckExists(input, locator, either.Argument.Specification);
return(CommandResult <TOutput> .Success(output.Serialize(exists), exists.ToString()));
}
catch (ArgumentException ex)
{
return(CommandResult <TOutput> .Fail(
ex.Message,
ex.GetDetailedExplanation() + @"
Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
}
protected TOutput ExecuteCommand <TOutput>(ISerialization <TOutput> output, IServiceProvider locator, TCommand command)
{
var domainStore = locator.Resolve <IEventStore>();
try
{
domainStore.Submit(command);
}
catch (SecurityException) { throw; }
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
new FrameworkException("Error while submitting query: {0}".With(ex.Message), ex));
}
try
{
return(output.Serialize(OutMethod.Invoke(null, new object[] { command })));
}
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
new FrameworkException(@"Error serializing result: " + ex.Message, ex));
}
}
public ICommandResult <TOutput> Execute <TInput, TOutput>(
IServiceProvider locator,
ISerialization <TInput> input,
ISerialization <TOutput> output,
IPrincipal principal,
TInput data)
{
var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument);
if (either.Error != null)
{
return(either.Error);
}
if (either.Argument.Uri == null)
{
return(CommandResult <TOutput> .Fail("Uri not provided.", @"Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
try
{
var arg = new GetDomainObject.Argument {
Name = either.Argument.Name, Uri = new[] { either.Argument.Uri }
};
var result = GetDomainObject.GetData(locator, arg, principal);
return(CommandResult <TOutput> .Success(output.Serialize(result.Length == 1), result.Length == 1? "Found" : "Not found"));
}
catch (ArgumentException ex)
{
return(CommandResult <TOutput> .Fail(
ex.Message,
ex.GetDetailedExplanation() + @"
Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
}
public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
{
var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);
if (either.Error != null)
{
return(either.Error);
}
try
{
var table = PopulateTable(input, output, Locator, DomainModel, either.Argument, Permissions);
if (either.Argument.UseDataTable)
{
return(CommandResult <TOutput> .Return(HttpStatusCode.Created, output.Serialize(table), "Data analyzed"));
}
var result = ConvertTable.Convert(output, table);
return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Data analyzed"));
}
catch (SecurityException ex)
{
return(CommandResult <TOutput> .Return(HttpStatusCode.Forbidden, default(TOutput), ex.Message));
}
catch (ArgumentException ex)
{
return(CommandResult <TOutput> .Fail(
ex.Message,
ex.GetDetailedExplanation() + @"
Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
}
public Stream ConvertStream <TCommand, TArgument>(TArgument argument)
{
var match = new UriTemplateMatch();
match.RelativePathSegments.Add(typeof(TCommand).FullName);
ThreadContext.Request.UriTemplateMatch = match;
if (argument == null)
{
return(Application.Get());
}
switch (ThreadContext.Request.ContentType)
{
case "application/x-protobuf":
return(Application.Post(Protobuf.Serialize(argument)));
case "application/json":
return(Application.Post(Json.Serialize(argument).BaseStream));
}
using (var ms = ChunkedMemoryStream.Create())
{
var sw = ms.GetWriter();
sw.Write(Xml.Serialize(argument));
sw.Flush();
ms.Position = 0;
return(Application.Post(ms));
}
}
public void Queue <TInput>(
ISerialization <TInput> input,
IServiceProvider locator,
IDataContext context,
TInput data)
{
TEvent domainEvent;
try
{
domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>();
}
catch (Exception ex)
{
throw new ArgumentException("Error deserializing domain event.", ex);
}
try
{
context.Queue(domainEvent);
}
catch (SecurityException) { throw; }
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
data == null
? new FrameworkException("Error while queuing event: {0}. Data not sent.".With(ex.Message), ex)
: new FrameworkException(@"Error while queuing event: {0}. Sent data:
{1}".With(ex.Message, input.Serialize(domainEvent)), ex));
}
}
public void SendMessage(object obj)
{
if (obj == null)
{
return;
}
object sobj = _serialization.Serialize(obj);
if (sobj is byte[])
{
byte[] bytes = (byte[])sobj;
if (bytes == null || bytes.Length == 0)
{
return;
}
IBytesMessage message = _service.session.CreateBytesMessage();
message.WriteBytes(bytes);
_producer.Send(message);
}
else if (sobj is string)
{
string str = (string)sobj;
ITextMessage txt = _service.session.CreateTextMessage();
_producer.Send(txt);
}
else
{
throw new Exception("obj is undefined type!");
}
}
public void Create(TValue value)
{
EnsureFileExistence();
using (var writer = File.AppendText(fileName))
{
writer.Write($"{serialization.Serialize(value)}\n");
}
}
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType)
{
try
{
var array = Array.CreateInstance(rootType, 1);
var element = TemporaryResources.CreateRandomObject(rootType);
array.SetValue(element, 0);
return(serializer.Serialize(new Argument <TFormat> {
RootName = rootType.FullName, ToInsert = serializer.Serialize((dynamic)array)
}));
}
catch
{
//fallback to simple example since sometimes calculated properties will throw exception during serialization
return(CreateExampleArgument(serializer));
}
}
public TOutput Queue <TInput, TOutput>(
ISerialization <TInput> input,
ISerialization <TOutput> output,
IServiceProvider locator,
string uri,
TInput data)
{
TEvent domainEvent;
try
{
domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>();
}
catch (Exception ex)
{
throw new ArgumentException("Error deserializing domain event.", ex);
}
var repository = locator.Resolve <IRepository <TAggregate> >();
var aggregate = repository.Find(uri);
if (aggregate == null)
{
throw new ArgumentException("Can't find aggregate with Uri: {0}".With(uri));
}
try { domainEvent.Apply(aggregate); }
catch (SecurityException) { throw; }
catch (Exception ex)
{
throw new ArgumentException(ex.Message, ex);
}
var eventStore = locator.Resolve <IDomainEventStore>();
try { eventStore.Queue(domainEvent); }
catch (SecurityException) { throw; }
catch (Exception ex)
{
throw new ArgumentException(
ex.Message,
data == null
? new FrameworkException("Error while Queuing event: {0}. Data not sent.".With(ex.Message), ex)
: new FrameworkException(@"Error while Queuing event: {0}. Sent data:
{1}".With(ex.Message, output.Serialize(domainEvent)), ex));
}
return(output.Serialize(aggregate));
}
public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
{
var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);
if (either.Error != null)
{
return(either.Error);
}
var argument = either.Argument;
var rootType = DomainModel.Find(argument.RootName);
if (rootType == null)
{
return(CommandResult <TOutput> .Fail("Couldn't find root type {0}.".With(argument.RootName), @"Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
if (!typeof(IAggregateRoot).IsAssignableFrom(rootType))
{
return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an aggregate root.
Please check your arguments.".With(argument.RootName), null));
}
if (!Permissions.CanAccess(rootType))
{
return
(CommandResult <TOutput> .Return(
HttpStatusCode.Forbidden,
default(TOutput),
"You don't have permission to access: {0}.",
argument.RootName));
}
if (argument.ToInsert == null && argument.ToUpdate == null && argument.ToDelete == null)
{
return(CommandResult <TOutput> .Fail("Data to persist not specified.", @"Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, rootType))));
}
try
{
var commandType = typeof(PersistAggregateRootCommand <>).MakeGenericType(rootType);
var command = Activator.CreateInstance(commandType) as IPersistAggregateRootCommand <IAggregateRoot>;
var uris = command.Persist(input, Locator, argument.ToInsert, argument.ToUpdate, argument.ToDelete);
return(CommandResult <TOutput> .Success(output.Serialize(uris), "Data persisted"));
}
catch (ArgumentException ex)
{
return(CommandResult <TOutput> .Fail(
ex.Message,
ex.GetDetailedExplanation() + @"
Example argument:
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
}
}
private Message Serialize(object o)
{
var type = o.GetType().Name;
var data = _serialization.Serialize(o);
var msg = new Message(data);
msg.UserProperties["ClrType"] = msg;
return(msg);
}
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType)
{
try
{
return
(serializer.Serialize(
new Argument <TFormat>
{
Name = rootType.FullName,
Data = serializer.Serialize((dynamic)TemporaryResources.CreateRandomObject(rootType))
}));
}
catch
{
//fallback to simple example since sometimes calculated properties will throw exception during serialization
return(CreateExampleArgument(serializer));
}
}
protected void EncodeRequest(IChannel channel, IByteBuffer buffer, Request req)
{
//Console.WriteLine("begin encode Request:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
ISerialization serialization = GetSerialization(channel);
// Console.WriteLine("get serialization:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
// header.
byte[] header = new byte[HeaderLength];
// set magic number.
ByteUtil.Short2Bytes(Magic, header);
// set request and serialization flag.
header[2] = (byte)(FlagRequest | serialization.GetContentTypeId());
if (req.IsTwoWay)
{
header[2] |= FlagTwoway;
}
if (req.IsEvent)
{
header[2] |= FlagEvent;
}
// set request id.
ByteUtil.Long2Bytes(req.Mid, header, 4);
// encode request data.
int savedWriteIndex = buffer.WriterIndex;
buffer.SetWriterIndex(savedWriteIndex + HeaderLength);
ChannelBufferStream bos = new ChannelBufferStream(buffer);
IObjectOutput output = serialization.Serialize(bos);
//Console.WriteLine("encode header:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
if (req.IsEvent)
{
EncodeEventData(channel, output, req.Mdata);
}
else
{
EncodeRequestData(channel, output, req.Mdata);
}
//Console.WriteLine("encode requestdata down:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
output.FlushBuffer();
bos.Flush();
bos.Close();
int len = bos.WritenBytes();
CheckPayload(channel, len);
ByteUtil.Int2Bytes(len, header, 12);
// write
buffer.SetWriterIndex(savedWriteIndex);
buffer.WriteBytes(header); // write header.
buffer.SetWriterIndex(savedWriteIndex + HeaderLength + len);
// Console.WriteLine("encode end:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
}
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer)
{
return
(serializer.Serialize(
new Argument <TFormat>
{
Name = "Module.Entity",
SpecificationName = "Module.Entity+FindImportant"
}));
}
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType)
{
return
(serializer.Serialize(
new Argument
{
Name = rootType.FullName,
Uri = "1001"
}));
}
public TOutput Create <TInput, TOutput>(
ISerialization <TInput> input,
ISerialization <TOutput> output,
IServiceProvider locator,
bool returnInstance,
TInput data)
{
TRoot root;
try
{
root = input.Deserialize <TInput, TRoot>(data, locator);
}
catch (Exception ex)
{
throw new ArgumentException(
"Error deserializing: " + ex.Message,
new FrameworkException(@"Sent data:
{0}".With(data), ex));
}
try
{
var repository = locator.Resolve <IPersistableRepository <TRoot> >();
repository.Insert(root);
return(returnInstance ? output.Serialize(root) : output.Serialize(root.URI));
}
catch (Exception ex)
{
string additionalInfo;
try
{
additionalInfo = @"Sent data:
" + input.Serialize(root);
}
catch (Exception sex)
{
additionalInfo = "Error serializing input: " + sex.Message;
}
throw new ArgumentException(
"Error saving: " + ex.Message,
new FrameworkException(additionalInfo, ex));
}
}
public TOutput Transform(ISerialization <TInput> input, ISerialization <TOutput> output, TInput value)
{
var arg = input.Deserialize <TInput, string[]>(value);
return(output.Serialize(new GetDomainObject.Argument
{
Name = Name,
Uri = arg
}));
}
public TOutput Find <TOutput>(
ISerialization <TOutput> output,
IServiceLocator locator,
IPermissionManager permissions,
string uri)
{
var repository = locator.Resolve <IRepository <TDomainObject> >();
var data = repository.Find(new[] { uri });
var filtered = permissions.ApplyFilters(data).FirstOrDefault();
return(filtered != null?output.Serialize(filtered) : default(TOutput));
}
public async void SaveAll()
{
foreach (var statistic in _statisticsCache)
{
if (statistic.Value.PlayerId == Guid.Empty)
{
throw new Exception("INVALID PLAYER NAME");
}
_statisticsSerialiser.FileName = statistic.Value.PlayerId + ".XML";
await _statisticsSerialiser.Serialize(statistic.Value);
}
}
public static void Send <T>(ISerialization serializer, StreamWriter stream, T item)
{
try
{
byte[] data = serializer.Serialize <T>(item);
stream.Write(Encoding.UTF8.GetString(data).ToCharArray());
stream.Write('\0');
stream.Flush();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// Retruns bytes from the object
/// </summary>
/// <typeparam name="T">Type of the object</typeparam>
/// <param name="input">Object to use for serialization</param>
/// <param name="iSerialization">Serialization instance</param>
/// <returns>Serialized byte array</returns>
public static byte[] ToBytes <T>(this T _object, ISerialization _iSerialization)
{
if (IsSerializable <T>(_object) == false)
{
throw new InvalidOperationException("This object is not serializable");
}
using (Stream stream = _iSerialization.Serialize <T>(_object))
{
stream.Seek(0, SeekOrigin.Begin);
byte[] retValue = new byte[stream.Length];
stream.Read(retValue, 0, retValue.Length);
return(retValue);
}
}