public IMessageEnvelope ProcessMessage(IMessageEnvelope message)
{
var response = connector.SendEnvelope(message);
if (response == null)
{
throw new InvalidOperationException("Unable to obtain a response from the server.");
}
if (response.Error != null)
{
var sb = new StringBuilder();
if (null != response.Error)
{
sb.Append(response.Error.ErrorMessage);
sb.AppendFormat(", ErrorCode: {0}", response.Error.ErrorCode);
sb.AppendFormat(", ErrorClass: {0}", response.Error.ErrorClass);
}
else
{
sb.Append("response.Error == null");
}
// ServerError class is not an exception!!! so it have no stack trace...
throw new DeveelDbServerException(sb.ToString(), -1, -1);
}
var content = connector.OpenEnvelope(response);
connector.OnMessageReceived(content);
return(response);
}
/// <summary>
/// Serializes the envelope.
/// </summary>
/// <param name="instance">The instance.</param>
/// <returns></returns>
public string SerializeEnvelope(IMessageEnvelope instance)
{
try
{
instance.MessageType = instance.Message.GetType().AssemblyQualifiedName;
instance.MessageString = SerializeMessage(instance.Message);
}
catch (System.Exception ex)
{
throw new MessageSerializationException("Could not serialize Message " + instance.MessageType + " for " + instance.Originator + " in " + instance.MessageUID, ex, instance);
}
string serializeString = string.Empty;
try
{
var stream = new MemoryStream();
var xmlSerializer = new XmlSerializer(typeof(MessageEnvelope));
xmlSerializer.Serialize(stream, instance);
byte[] serializeBytes = stream.ToArray();
serializeString = System.Text.ASCIIEncoding.UTF8.GetString(serializeBytes);
}
catch (System.Exception ex)
{
throw new MessageSerializationException("Could not serialize Message Envelope with Message " + instance.MessageType + " for " + instance.Originator + " in " + instance.MessageUID, ex, instance);
}
return(serializeString);
}
private IMessage Request(IMessageEnvelope envelope)
{
connector.SendEnvelope(envelope);
var response = connector.ReceiveResponse(connector.Timeout, envelope.Metadata);
return(connector.OnProcessServerResponse(response));
}
/// <inheritdoc />
public Type Decode(IMessageEnvelope storage)
{
storage = Arguments.EnsureNotNull(storage, nameof(storage));
var header = storage.Headers["AssemblyQualifiedName"];
string aqn;
if (header is byte[] headerBytes)
{
aqn = Encoding.ASCII.GetString(headerBytes);
}
else
{
aqn = (string)header;
}
if (aqn == null)
{
throw new AbbotwareException("Message header is missing Assembly Qualified Name");
}
var type = Type.GetType(aqn, false);
if (type == null)
{
throw AbbotwareException.Create("unable to load assembly containing type info:{0}", aqn);
}
return(type);
}
protected void SendEnvelope(IMessageEnvelope envelope)
{
lock (channelLock) {
var bytes = SerializeEnvelope(envelope);
OutputStream.Write(bytes, 0, bytes.Length);
OutputStream.Flush();
}
}
public Task PublishMessage(IMessageEnvelope message)
{
return Task.Run(() =>
{
var hubContext = _connectionManager.GetHubContext<WebSocketClientChannelSender>();
hubContext.Clients.All.recieveMessage(message);
});
}
public Task PublishMessage(IMessageEnvelope message)
{
return(Task.Run(() =>
{
var hubContext = _connectionManager.GetHubContext <WebSocketClientChannelSender>();
hubContext.Clients.All.recieveMessage(message);
}));
}
public Task WriteAsync(IMessageEnvelope messageEnvelope, CancellationToken cancellationToken = default)
{
return(Task.Run(() =>
{
this.Write(messageEnvelope);
},
cancellationToken));
}
public override Task <String> SerializeMessageEnvelopeAsync(IMessageEnvelope messageEnvelope, CancellationToken cancellationToken = default)
{
return(Task.Run(() =>
{
return this.MessageParser.SerializeMessageEnvelope(messageEnvelope);
},
cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="Received{TMessage}" /> class.
/// </summary>
/// <param name="content">typed message data</param>
/// <param name="envelope">message evenlope metadata</param>
public Received(TContent content, IMessageEnvelope envelope)
{
Arguments.NotNull(content, nameof(content));
Arguments.NotNull(envelope, nameof(envelope));
this.Content = content;
this.Envelope = envelope;
}
public IMessageEnvelope ProcessMessage(IMessageEnvelope envelope)
{
var metadata = envelope.Metadata;
var message = connector.GetMessage(envelope);
if (message == null)
{
return(CreateErrorResponse(metadata, new Exception("No message found in the envelope.")));
}
if (message is ConnectRequest)
{
return(ProcessConnect(metadata, (ConnectRequest)message));
}
if (message is AuthenticateRequest)
{
return(ProcessAuthenticate(metadata, (AuthenticateRequest)message));
}
if (message is QueryExecuteRequest)
{
return(ProcessQuery(metadata, (QueryExecuteRequest)message));
}
if (message is QueryResultPartRequest)
{
return(ProcessQueryPart(metadata, (QueryResultPartRequest)message));
}
if (message is DisposeResultRequest)
{
return(ProcessDisposeResult(metadata, (DisposeResultRequest)message));
}
if (message is LargeObjectCreateRequest)
{
return(ProcessCreateLargeObject(metadata, (LargeObjectCreateRequest)message));
}
if (message is BeginRequest)
{
return(ProcessBegin(metadata));
}
if (message is CommitRequest)
{
return(ProcessCommit(metadata, (CommitRequest)message));
}
if (message is RollbackRequest)
{
return(ProcessRollback(metadata, (RollbackRequest)message));
}
if (message is CloseRequest)
{
return(ProcessClose(metadata));
}
return(CreateErrorResponse(envelope, "Message not supported"));
}
protected virtual byte[] SerializeEnvelope(IMessageEnvelope envelope)
{
using (var stream = new MemoryStream()) {
var formatter = new BinaryFormatter();
formatter.Serialize(stream, envelope);
stream.Flush();
return(stream.ToArray());
}
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="queueName">Name of the queue.</param>
/// <param name="messageEnvelope">The message envelope.</param>
public void SendMessage(string queueName, IMessageEnvelope messageEnvelope)
{
foreach (IQueueAdapter queueManager in _queueManagers)
{
if (queueManager.QueueName == queueName)
{
queueManager.SendMessage(messageEnvelope);
}
}
}
void IBusLogger.LogPublishFailure(IMessageEnvelope envelope, string failureMessage, System.Exception exceptionOccurred, Type messageType)
{
try
{
MessagingPublisherLog(envelope, messageType.FullName, false, failureMessage, exceptionOccurred);
}
catch (System.Exception ex)
{
}
}
/// <summary>
/// Recieves the message async.
/// </summary>
protected void ReceiveMessageAsync()
{
SqlDataReader reader = null;
while (!_isStop)
{
try
{
reader = _sqlQueueHelper.ReceiveMessage(true, Convert.ToInt32(_configuration.timeoutInSeconds.Name), true, _configuration.queue.Name, _connection);
while (reader.Read())
{
byte[] messageBytes = (byte[])reader.GetValue(13);
String messageText = ASCIIEncoding.ASCII.GetString(messageBytes);
if (!string.IsNullOrEmpty(messageText))
{
IMessageEnvelope envelope = null;
try
{
envelope = _serializer.DeserializeEnvelope(messageText);
_logger.LogAdapterSuccess(envelope, "Message Received:" + envelope.MessageUID, this.GetType());
if (envelope != null)
{
OnMessage(envelope);
}
}
catch (System.Exception ex)
{
_logger.LogAdapterFailure(envelope, ex.Message, ex, this.GetType());
}
}
}
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message, ex);
if (_connection.State == ConnectionState.Closed)
{
_connection.Open();
}
Thread.Sleep(2000);
}
finally
{
if (reader != null)
{
reader.Close();
}
Thread.Sleep(100);
}
}
}
public void MessagingQueueLog(IMessageEnvelope envelope, string adapterType, bool isSuccess, string message, System.Exception occurredException)
{
if (envelope != null)
{
MessagingQueueLog(envelope.MessageUID, envelope.MessageSentOn, adapterType, isSuccess, message, occurredException, ConfigurationHelper.GetEnvironment(envelope));
}
else
{
MessagingQueueLog(null, null, adapterType, isSuccess, message, occurredException, null);
}
}
public void MessagingHostLog(IMessageEnvelope envelope, string busType, bool isSuccess, string message, System.Exception occurredException)
{
if (envelope != null)
{
MessagingHostLog(envelope.MessageUID, envelope.MessageSentOn, envelope.Originator, busType, isSuccess, message, occurredException, ConfigurationHelper.GetEnvironment(envelope));
}
else
{
MessagingHostLog(null, null, string.Empty, busType, isSuccess, message, occurredException, null);
}
}
private IMessageEnvelope CreateErrorResponse(IMessageEnvelope sourceMessage, Exception error)
{
IDictionary <string, object> metadata = null;
if (sourceMessage != null)
{
metadata = sourceMessage.Metadata;
}
return(CreateErrorResponse(metadata, error));
}
public async Task <R> HandleAsync <T, R>(IMessageEnvelope <T> message)
{
var handler = Handler as Func <IMessageEnvelope <T>, Task>;
if (handler == null)
{
throw new InvalidCastException($"Invalid cast from {Handler.GetType()} to Func<IMessageEnvelope<{typeof(T).Name}>, Task<object>>");
}
await handler(message);
return(default);
protected virtual IMessage GetMessage(IMessageEnvelope envelope)
{
if (envelope == null)
{
return(null);
}
// TODO: handle errors? it's not supposed the client to send errors to the server ...
return(envelope.Message);
}
public void MessagingSubscriberLog(IMessageEnvelope envelope, string subscriberType, bool isSuccess, string message, System.Exception occurredException)
{
if (envelope != null)
{
MessagingSubscriberLog(envelope.MessageUID, envelope.MessageSentOn, subscriberType, isSuccess, message, 0, occurredException, false, false, 0, false, null, 0, ConfigurationHelper.GetEnvironment(envelope));
}
else
{
MessagingSubscriberLog(null, null, subscriberType, isSuccess, message, 0, occurredException, false, false, 0, false, null, 0, null);
}
}
public void Send(IMessageEnvelope envelope)
{
var message = new MailMessage();
message.To.Add(new MailAddress(envelope.To));
message.Subject = envelope.Subject;
message.Body = envelope.Content.Content;
message.IsBodyHtml = true;
var client = new SmtpClient();
client.Send(message);
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="messageEnvelope">The message envelope.</param>
public void SendMessage(IMessageEnvelope messageEnvelope)
{
try
{
// _azureQueueHelper.SendMessage(messageEnvelope);
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message, ex);
throw;
}
}
public RequestIndices(IMessageEnvelope message)
{
_id = message.Context.Id;
var indices = message.Indices;
_duration = indices.GetValueOrDefault("request.duration") as float?;
_statusCode = indices.GetValueOrDefault("request.statuscode") as int?;
_url = indices.GetValueOrDefault("request.url") as string;
_method = indices.GetValueOrDefault("request.method") as string;
_statusCode = indices.GetValueOrDefault("request.statuscode") as int?;
}
public override IMessageEnvelope GenerateDebugMessage()
{
try {
INeuraliumDebugMessage message = new NeuraliumDebugMessage();
message.Message = "allo :)";
IMessageEnvelope envelope = this.GenerateBlockchainMessage(message);
return(envelope);
} catch (Exception ex) {
throw new ApplicationException("failed to generate neuralium debug message", ex);
}
}
/// <inheritdoc />
public virtual TMessage Decode <TMessage>(IMessageEnvelope storage)
{
storage = Arguments.EnsureNotNull(storage, nameof(storage));
var type = this.typeEncoder.Decode(storage);
if (type != null && type != typeof(TMessage))
{
throw AbbotwareException.Create("Message type Mismatch! Message Contains:{0} Caller Expects:{1} maybe you should call the non generic decode, or use a MessageGetter / Cosumer that supports callback's per message type", type.AssemblyQualifiedName !, typeof(TMessage).AssemblyQualifiedName !);
}
return(this.Serializer.Decode <TMessage>(storage.Body.ToArray()));
}
protected virtual void OnTriggerNotification(IMessageEnvelope envelope)
{
if (triggerChannels == null)
{
return;
}
lock (triggerChannels) {
foreach (var channel in triggerChannels)
{
}
}
}
protected virtual IMessage OnProcessServerResponse(IMessageEnvelope envelope)
{
if (envelope == null)
{
return(null);
}
if (envelope.Error != null)
{
throw new DeveelDbException(envelope.Error.ErrorMessage, envelope.Error.ErrorClass, envelope.Error.ErrorCode);
}
return(envelope.Message);
}
public void Send(IMessageEnvelope envelope)
{
var message = new MailMessage();
message.To.Add(new MailAddress(envelope.To));
message.Subject = envelope.Subject;
message.Body = envelope.Content.Content;
message.IsBodyHtml = true;
var client = new SmtpClient();
client.Send(message);
}
public override async Task <R> HandleAsync <T, R>(IMessageEnvelope <T> message)
{
while (true)
{
try
{
return(await _asyncCommandHandler.HandleAsync <T, R>(message).ConfigureAwait(false));
}
catch when(_retryCount-- > 0)
{
}
}
}
public void SerializeMessage(IMessageEnvelope<object> message, IModel model, out IBasicProperties headers, out byte[] body, out string routingKey)
{
Stream stream = Serializer.Serialize(message);
var messageBuilder = new MapMessageBuilder(model);
messageBuilder.Headers[MessageTypeHeader] = message.GetType().GetGenericArguments()[0].AssemblyQualifiedName;
headers = (IBasicProperties)messageBuilder.GetContentHeader();
routingKey = message.Message.GetType().ToRoutingKey();
body = new byte[stream.Length];
stream.Read(body, 0, body.Length);
}
public static string GetEnvironment(IMessageEnvelope envelope)
{
string environment = string.Empty;
if (envelope != null)
{
if (!string.IsNullOrEmpty(envelope.Environment))
{
environment = envelope.Environment;
}
}
return(environment);
}
/// <summary>
/// Called when [message].
/// </summary>
/// <param name="messageEnvelope">The message envelope.</param>
/// <param name="specificSubscribers">The specific subscribers.</param>
void OnMessage(IMessageEnvelope messageEnvelope, IList <string> specificSubscribers)
{
_logger.LogBusReceived(messageEnvelope, "");
try
{
var session = new SessionContext();
var OnMessageCall = new OnMessageAsync(_subscriberManager.OnMessage);
OnMessageCall.BeginInvoke(messageEnvelope, specificSubscribers, null, this);
}
catch (System.Exception exception)
{
_logger.LogBusReceivedFailure(messageEnvelope, exception.Message, exception);
}
}
public IMessageEnvelope ProcessMessage(IMessageEnvelope envelope)
{
var metadata = envelope.Metadata;
var message = connector.GetMessage(envelope);
if (message == null)
return CreateErrorResponse(metadata, new Exception("No message found in the envelope."));
if (message is ConnectRequest)
return ProcessConnect(metadata, (ConnectRequest)message);
if (message is AuthenticateRequest)
return ProcessAuthenticate(metadata, (AuthenticateRequest)message);
if (message is QueryExecuteRequest)
return ProcessQuery(metadata, (QueryExecuteRequest)message);
if (message is QueryResultPartRequest)
return ProcessQueryPart(metadata, (QueryResultPartRequest)message);
if (message is DisposeResultRequest)
return ProcessDisposeResult(metadata, (DisposeResultRequest)message);
if (message is LargeObjectCreateRequest)
return ProcessCreateLargeObject(metadata, (LargeObjectCreateRequest)message);
if (message is BeginRequest)
return ProcessBegin(metadata);
if (message is CommitRequest)
return ProcessCommit(metadata, (CommitRequest)message);
if (message is RollbackRequest)
return ProcessRollback(metadata, (RollbackRequest)message);
if (message is CloseRequest)
return ProcessClose(metadata);
return CreateErrorResponse(envelope, "Message not supported");
}
private IMessageEnvelope CreateErrorResponse(IMessageEnvelope sourceMessage, string message)
{
return CreateErrorResponse(sourceMessage, new ProtocolException(message));
}
protected void SendEnvelope(IMessageEnvelope envelope)
{
lock (channelLock) {
var bytes = SerializeEnvelope(envelope);
OutputStream.Write(bytes, 0, bytes.Length);
OutputStream.Flush();
}
}
protected virtual IMessage GetMessage(IMessageEnvelope envelope)
{
if (envelope == null)
return null;
// TODO: handle errors? it's not supposed the client to send errors to the server ...
return envelope.Message;
}
private IMessage Ping(IMessageEnvelope envelope)
{
return Request(envelope);
}
public IMessageEnvelope ProcessMessage(IMessageEnvelope message)
{
var response = connector.SendEnvelope(message);
if (response == null)
throw new InvalidOperationException("Unable to obtain a response from the server.");
if (response.Error != null)
throw new ServerException(response.Error.ErrorMessage);
var content = connector.OpenEnvelope(response);
connector.OnMessageReceived(content);
return response;
}
private IMessage RequestConnect(IMessageEnvelope envelope)
{
try {
var request = (ConnectRequest) envelope.Message;
connector.Timeout = request.Timeout;
connector.OpenConnector(request.RemoteEndPoint);
var response = Request(envelope);
var responseMessage = (ConnectResponse) response;
if (!responseMessage.Opened) {
connector.Close();
throw new InvalidOperationException();
}
return response;
} catch (Exception) {
//TODO:
throw;
}
}
protected abstract IMessageEnvelope SendEnvelope(IMessageEnvelope envelope);
protected override IMessageEnvelope SendEnvelope(IMessageEnvelope envelope)
{
return ServerMessageProcessor.ProcessMessage(envelope);
}
public PipelineEventArgs(IMessageEnvelope<object> envelope)
{
MessageEnvelope = envelope;
}
private IMessage RequestQueryExecute(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
private IMessage RequestCreateLargeObject(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
private IMessage RequestCreateTrigger(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
private IMessageEnvelope CreateErrorResponse(IMessageEnvelope sourceMessage, Exception error)
{
IDictionary<string, object> metadata = null;
if (sourceMessage != null)
metadata = sourceMessage.Metadata;
return CreateErrorResponse(metadata, error);
}
public IMessageEnvelope ProcessMessage(IMessageEnvelope envelope)
{
var message = envelope.Message;
IMessage response = null;
if (message is ConnectRequest)
response = RequestConnect(envelope);
else if (message is AuthenticateRequest)
response = RequestAuthenticate(envelope);
else if (message is QueryExecuteRequest)
response = RequestQueryExecute(envelope);
else if (message is QueryResultPartRequest)
response = RequestQueryResultPart(envelope);
else if (message is DisposeResultRequest)
response = RequestDisposeResult(envelope);
else if (message is LargeObjectCreateRequest)
response = RequestCreateLargeObject(envelope);
else if (message is LargeObjectDisposeRequest)
response = RequestDisposeLargeObject(envelope);
else if (message is TriggerCreateRequest)
response = RequestCreateTrigger(envelope);
else if (message is BeginRequest)
response = RequestBegin(envelope);
else if (message is CommitRequest)
response = RequestCommit(envelope);
else if (message is RollbackRequest)
response = RequestRollback(envelope);
else if (message is PingRequest)
response = Ping(envelope);
else if (message is CloseRequest)
response = RequestClose(envelope);
if (response == null)
throw new NotSupportedException();
return CreateResponse(envelope.Metadata, response);
}
protected virtual IMessage OpenEnvelope(IMessageEnvelope envelope)
{
return envelope.Message;
}
protected virtual byte[] SerializeEnvelope(IMessageEnvelope envelope)
{
using (var stream = new MemoryStream()) {
var formatter = new BinaryFormatter();
formatter.Serialize(stream, envelope);
stream.Flush();
return stream.ToArray();
}
}
public IMessageEnvelope ProcessMessage(IMessageEnvelope message)
{
var response = connector.SendEnvelope(message);
if (response == null)
throw new InvalidOperationException("Unable to obtain a response from the server.");
if (response.Error != null)
{
var sb = new StringBuilder();
if (null != response.Error) {
sb.Append (response.Error.ErrorMessage);
sb.AppendFormat (", ErrorCode: {0}", response.Error.ErrorCode);
sb.AppendFormat (", ErrorClass: {0}", response.Error.ErrorClass);
}
else
sb.Append ("response.Error == null");
// ServerError class is not an exception!!! so it have no stack trace...
throw new DeveelDbServerException (sb.ToString(), -1, -1);
}
var content = connector.OpenEnvelope(response);
connector.OnMessageReceived(content);
return response;
}
private IMessage RequestQueryResultPart(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
private IMessage RequestCommit(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
private IMessage RequestDisposeResult(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
protected virtual bool ShouldReceive(IDictionary<string, object> senderMetadata, IMessageEnvelope envelope)
{
var senderId = ExtractDispatchId(senderMetadata);
var envelopeId = ExtractDispatchId(envelope.Metadata);
return senderId == envelopeId;
}
private IMessage RequestClose(IMessageEnvelope envelope)
{
try {
var response = Request(envelope);
var responseMessage = (AcknowledgeResponse) response;
if (!responseMessage.State)
throw new InvalidOperationException();
connector.Close();
return response;
} catch (Exception) {
throw;
}
}
private IMessage RequestAuthenticate(IMessageEnvelope envelope)
{
try {
connector.AssertOpen();
var response = Request(envelope);
var responseMessage = (AuthenticateResponse) response;
if (!responseMessage.Authenticated)
throw new InvalidOperationException();
connector.OnAuthenticated(((AuthenticateRequest)envelope.Message).UserName, responseMessage.TimeStamp);
return response;
} catch (Exception) {
throw;
}
}
private IMessage Request(IMessageEnvelope envelope)
{
connector.SendEnvelope(envelope);
var response = connector.ReceiveResponse(connector.Timeout, envelope.Metadata);
return connector.OnProcessServerResponse(response);
}
protected virtual void OnTriggerNotification(IMessageEnvelope envelope)
{
if (triggerChannels == null)
return;
lock (triggerChannels) {
foreach (var channel in triggerChannels) {
}
}
}
private IMessage RequestRollback(IMessageEnvelope envelope)
{
throw new NotImplementedException();
}
