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); }