private async Task ParseClientToServerMessage(CoreComMessage request)
{
//this only hapend after first messages bin sent
if (request.MessageSignature == CoreComInternalSignatures.CoreComInternal_PullQueue)
{
await ParseCoreComFrameworkMessage(request);
return;
}
CoreComUserInfo coreComUserInfo = new CoreComUserInfo {
ClientId = request.ClientId
};
if (string.IsNullOrEmpty(request.JsonObject))
{
CoreComMessagingCenter.Send(request.MessageSignature, coreComUserInfo);
}
else
{
var objectDeser = JsonSerializer.Deserialize(request.JsonObject, CoreComMessagingCenter.GetMessageArgType(request.MessageSignature));
CoreComMessagingCenter.Send(request.MessageSignature, coreComUserInfo, objectDeser);
}
}
private async Task SubscribeServerToClientInternal(CoreComMessage request, IServerStreamWriter <CoreComMessageResponse> responseStream, ServerCallContext context)
{
try
{
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
//Add loging
request.TransferStatus = (int)TransferStatusEnum.Recived;
request.RecivedUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime();
//Check if we alread has responde to this
if (!dbContext.IncomingMessages.Any(x => x.TransactionIdentifier == request.TransactionIdentifier))
{
await ParseClientToServerMessage(request);
//Logging
LogEventOccurred(dbContext, request);
}
}
//process cue
await ProcessQueue(request, responseStream, context).ConfigureAwait(false);
}
catch (Exception ex)
{
LogErrorOccurred(ex, new CoreComMessage
{
ClientId = request.ClientId
});
}
}
internal async virtual void LogErrorOccurred(string description, CoreComMessage coreComMessage, Exception ex = null)
{
LogError logError = new LogError {
Description = description
};
if (coreComMessage != null)
{
logError.ClientId = coreComMessage.ClientId;
logError.TransactionIdentifier = coreComMessage.TransactionIdentifier;
if (string.IsNullOrEmpty(description))
{
logError.Description = coreComMessage.MessageSignature;
}
}
if (ex != null)
{
logError.Stacktrace = ex.StackTrace;
}
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
//Messages
switch (_coreComOptions.LogSettings.LogErrorTarget)
{
case LogErrorTargetEnum.Database:
//allways remove CoreComInternal from IncomingMessages table
//if (coreComMessage.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue)
dbContext.LogErros.Add(logError);
break;
case LogErrorTargetEnum.TextFile:
//Create textfile log
await WriteErrorLogtoFile(logError).ConfigureAwait(false);
break;
case LogErrorTargetEnum.NoLoging:
//if (coreComMessage.TransferStatus != (int)TransferStatusEnum.New)
// dbContext.IncomingMessages.Remove(coreComMessage);
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
EventHandler <LogError> handler = OnLogErrorOccurred;
if (handler != null)
{
handler(this, logError);
}
}
/// <summary>
/// This is used by the framework dont use this from your own code
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task SubscribeServerToClient(CoreComMessage request, IServerStreamWriter <CoreComMessageResponse> responseStream, ServerCallContext context)
{
if (request.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue &&
CoreComMessagingCenter.GetMessageIsAuth(request.MessageSignature))
{
LogErrorOccurred("Client try to use function un Authenticated", request);
return;
}
await SubscribeServerToClientInternal(request, responseStream, context);
}
private async Task WriteOutgoingMessagesLog(CoreComMessage request)
{
if (_coreComOptions.LogSettings.LogMessageTarget != LogMessageTargetEnum.TextFile)
{
return;
}
// Set a variable to the Documents path.
string docPath = FileSystem.AppDataDirectory;
// Write the specified text asynchronously to a new file named "WriteTextAsync.txt".
using (StreamWriter outputFile = new StreamWriter(Path.Combine(docPath, "OutgoningMessages.log"), true))
{
await outputFile.WriteLineAsync(DateTime.UtcNow.ToString() + "\t" + request.CoreComMessageId + "\t" + request.MessageSignature + "\t" + request.ClientId + "\t" + request.TransactionIdentifier + "\t" + ((TransferStatusEnum)request.TransferStatus).ToString() + "\t" + request.CalculateSize().ToString() + Environment.NewLine);
}
}
private async Task <bool> SendInternalAsync(object outgoingObject, string messageSignature, bool sendAuth, bool noDeadline)
{
string jsonObject = string.Empty;
CoreComMessage coreComMessage;
try
{
//Turn of timmer for message queue as we get the queue from this call
_checkQueueTimer.Enabled = false;
//error report to client
if (outgoingObject != null)
{
jsonObject = JsonSerializer.Serialize(outgoingObject);
}
coreComMessage = new CoreComMessage
{
CoreComMessageId = Guid.NewGuid().ToString(),
TransactionIdentifier = Guid.NewGuid().ToString(),
NewUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime(),
MessageSignature = messageSignature,
JsonObject = jsonObject,
SendAuth = sendAuth
};
using (var dbContext = new CoreComContext(_dbContextOptions))
{
dbContext.OutgoingMessages.Add(coreComMessage);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
await ProcessQueue(noDeadline).ConfigureAwait(false);
}
catch (Exception ex)
{
LogErrorOccurred(ex, new CoreComMessageResponse {
ClientId = _coreComOptions.ClientId
});
}
return(true);
}
private async Task ParseCoreComFrameworkMessage(CoreComMessage request)
{
//We need always responde with a message other vise loggin on client not work
//and the same CoreComInternal_PullQueue from client will send and wo will have the same
//transactionId twice result in db error
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
//queue is empty then create response message
if (!dbContext.OutgoingMessages.Any(x => x.ClientId == request.ClientId && x.TransferStatus < (int)TransferStatusEnum.Transferred))
{
//send
var internalMess = new CoreComMessageResponse
{
MessageSignature = CoreComInternalSignatures.CoreComInternal_PullQueue,
CoreComMessageResponseId = Guid.NewGuid().ToString(),
ClientId = request.ClientId,
NewUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime(),
TransactionIdentifier = Guid.NewGuid().ToString()
};
LogEventOccurred(dbContext, internalMess);
}
}
}
internal async virtual void LogEventOccurred(CoreComContext dbContext, CoreComMessage coreComMessage)
{
LogEvent logEvent = new LogEvent {
Description = coreComMessage.MessageSignature, TransferStatus = (TransferStatusEnum)coreComMessage.TransferStatus, MessageSize = coreComMessage.CalculateSize()
};
//Messages
switch (_coreComOptions.LogSettings.LogMessageTarget)
{
case LogMessageTargetEnum.Database:
//allways remove CoreComInternal from outgoingmessage table
if (coreComMessage.MessageSignature == CoreComInternalSignatures.CoreComInternal_PullQueue &&
coreComMessage.TransferStatus != (int)TransferStatusEnum.New)
{
dbContext.OutgoingMessages.Remove(coreComMessage);
}
//it's allready in db just update status
break;
case LogMessageTargetEnum.TextFile:
await WriteOutgoingMessagesLog(coreComMessage);
break;
case LogMessageTargetEnum.NoLoging:
if (coreComMessage.TransferStatus != (int)TransferStatusEnum.New)
{
dbContext.OutgoingMessages.Remove(coreComMessage);
}
break;
default:
break;
}
//Events
switch (_coreComOptions.LogSettings.LogEventTarget)
{
case LogEventTargetEnum.Database:
await dbContext.LogEvents.AddAsync(logEvent);
break;
case LogEventTargetEnum.TextFile:
await WriteEventLogtoFile(logEvent);
break;
case LogEventTargetEnum.NoLoging:
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
EventHandler <LogEvent> handler = OnLogEventOccurred;
if (handler != null)
{
handler(this, logEvent);
}
}
private async Task <bool> ProcessQueue(CoreComMessage request, IServerStreamWriter <CoreComMessageResponse> responseStream, ServerCallContext context)
{
//we have null ifall server restarted while client was connected
if (!_coreComOptions.Clients.Any(x => x.CoreComUserInfo.ClientId == request.ClientId))
{
AddClient(request.ClientId);
}
//check if we are sending allready
if (_coreComOptions.Clients.FirstOrDefault(x => x.CoreComUserInfo.ClientId == request.ClientId).ClientIsSending)
{
return(true);
}
_coreComOptions.Clients.FirstOrDefault(x => x.CoreComUserInfo.ClientId == request.ClientId).ClientIsSending = true;
try
{
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
//We need always responde with a message otherwise loggin on client not work
//and the same CoreComInternal_PullQueue from client will send and whe will have the same
//transactionId twice result in db error
var outgoingMess = dbContext.OutgoingMessages.
Where(x => x.ClientId == request.ClientId &&
x.TransferStatus < (int)TransferStatusEnum.Transferred).ToList();
foreach (var item in outgoingMess)
{
if (context.Deadline > DateTime.UtcNow)
{
//send
//await Task.Delay(7000);
await responseStream.WriteAsync(item);
//update messages
item.TransferStatus = (int)TransferStatusEnum.Transferred;
item.TransferredUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime();
LogEventOccurred(dbContext, item);
}
}
}
}
catch (RpcException ex)
{
LogEventOccurred(new LogEvent {
Description = ex.Message
});
switch (ex.StatusCode)
{
case StatusCode.DeadlineExceeded:
Console.WriteLine("DeadlineExceeded");
break;
case StatusCode.Cancelled:
Console.WriteLine("Stream cancelled.");
break;
case StatusCode.PermissionDenied:
case StatusCode.Unavailable:
Console.WriteLine("PermissionDenied/Unavailable");
break;
case StatusCode.Unauthenticated:
Console.WriteLine("Unauthenticated.");
break;
default:
break;
}
return(false);
}
catch (Exception ex)
{
LogErrorOccurred(ex, new CoreComMessage {
ClientId = request.ClientId, MessageSignature = request.MessageSignature
});
return(false);
}
finally
{
_coreComOptions.Clients.FirstOrDefault(x => x.CoreComUserInfo.ClientId == request.ClientId).ClientIsSending = false;
}
return(true);
}
internal async virtual void LogEventOccurred(CoreComContext dbContext, CoreComMessage coreComMessage)
{
LogEvent logEvent = new LogEvent
{
Description = coreComMessage.MessageSignature,
ClientId = coreComMessage.ClientId,
TransactionIdentifier = coreComMessage.TransactionIdentifier,
TransferStatus = (TransferStatusEnum)coreComMessage.TransferStatus,
MessageSize = coreComMessage.CalculateSize()
};
//Messages
switch (_coreComOptions.LogSettings.LogMessageTarget)
{
case LogMessageTargetEnum.Database:
//allways remove CoreComInternal from IncomingMessages table
if (coreComMessage.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue)
{
//the same message can get recived many times if deadline exced has happend
//its the TransactionIdentifier that connect them togheter
coreComMessage.CoreComMessageId = Guid.NewGuid().ToString();
dbContext.IncomingMessages.Add(coreComMessage);
}
break;
case LogMessageTargetEnum.TextFile:
//Create textfile log
if (coreComMessage.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue)
{
coreComMessage.CoreComMessageId = Guid.NewGuid().ToString();
await WriteIncommingMessagesLog(coreComMessage).ConfigureAwait(false);
}
break;
case LogMessageTargetEnum.NoLoging:
//if (coreComMessage.TransferStatus != (int)TransferStatusEnum.Recived)
//{
// dbContext.IncomingMessages.Remove(coreComMessage);
//}
break;
default:
break;
}
//Events
switch (_coreComOptions.LogSettings.LogEventTarget)
{
case LogEventTargetEnum.Database:
await dbContext.LogEvents.AddAsync(logEvent);
break;
case LogEventTargetEnum.TextFile:
//Create textfile log
await WriteEventLogtoFile(logEvent).ConfigureAwait(false);
break;
case LogEventTargetEnum.NoLoging:
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
EventHandler <LogEvent> handler = OnLogEventOccurred;
if (handler != null)
{
handler(this, logEvent);
}
}
internal async virtual void LogErrorOccurred(Exception exception, CoreComMessage coreComMessage)
{
LogErrorOccurred(exception.Message, coreComMessage, exception);
}
[Authorize] //Authenticated functions
public override async Task SubscribeServerToClientAuth(CoreComMessage request, IServerStreamWriter <CoreComMessageResponse> responseStream, ServerCallContext context)
{
await SubscribeServerToClientInternal(request, responseStream, context);
}
