protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is a nice test" }; for (int i = 0; i < _config.GetValue <int>("Service:Batch"); i++) { pkt.Readings.Add(await _factory.Generate(new Random().Next(1, 10000))); } var result = await Client.AddReadingAsync(pkt); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Succesfully sent"); } else { _logger.LogInformation("Failed to send"); } await Task.Delay(_config.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var customerId = _configuration.GetValue <int>("Service:CustomerId"); var pkt = new ReadingPacket() { Successful = MessageStatus.Success, Notes = "This is our test" }; for (int i = 0; i < 5; ++i) { pkt.Readings.Add(await _messageFactory.Generate(customerId)); } var result = await Client.AddReadingAsync(pkt); _logger.LogInformation(result.Success == MessageStatus.Success ? "Successfully sent" : "Failed to send"); await Task.Delay(_configuration.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
public override async Task <StatusMessage> AddReading(ReadingPacket request, ServerCallContext context) { if (request.Successful == ReadingStatus.Success) { foreach (var reading in request.Readings) { var readingValue = new MeterReading() { CustomerId = reading.CustomerId, Value = reading.ReadingValue, ReadingDate = reading.ReadingTime.ToDateTime() }; _logger.LogInformation($"Adding {reading.ReadingValue}"); _repository.AddEntity(readingValue); } if (await _repository.SaveAllAsync()) { _logger.LogInformation("Successfully Saved new Readings..."); return(new StatusMessage() { Notes = "Successfully added to the database.", Status = ReadingStatus.Success }); } } _logger.LogError("Failed to Saved new Readings..."); return(new StatusMessage() { Notes = "Failed to store readings in Database", Status = ReadingStatus.Success }); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = _config.GetValue <int>("Service:CustomerId"); while (!stoppingToken.IsCancellationRequested) { counter++; //if (counter % 10 == 0) //{ // Console.WriteLine("Sending Diagnostics"); // var stream = Client.SendDiagnostics(); // for (var i = 0; i < 3; i++) // { // var reading = await readingFactory.Generate(customerId); // await stream.RequestStream.WriteAsync(reading); // } // await stream.RequestStream.CompleteAsync(); //} var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is our test" }; for (var x = 0; x < 2; x++) { pkt.Readings.Add(await readingFactory.Generate(customerId)); } try { if (!NeedsLogin() || await GenerateToken()) { var headers = new Metadata(); headers.Add("Authorization", $"Bearer {_token}"); var result = await Client.AddReadingAsync(pkt, headers : headers); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Successful sent"); } else { _logger.LogInformation("Failed to send"); } } } catch (RpcException ex) { _logger.LogError($"Exception thrown: {ex}"); } _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); await Task.Delay(_config.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = this.config.GetValue <int>("Service:CustomerId"); while (!stoppingToken.IsCancellationRequested) { counter++; if (counter % 10 == 0) { Console.WriteLine("Sending Diagostics"); var stream = Client.SendDiagnostic(); for (int i = 0; i < 5; i++) { var reading = await this.readingFactory.Generate(customerId); await stream.RequestStream.WriteAsync(reading); } await stream.RequestStream.CompleteAsync(); } logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is a test" }; for (int i = 0; i < 5; i++) { var reading = await this.readingFactory.Generate(customerId); pkt.Readings.Add(reading); } var result = await Client.AddReadingAsync(pkt); if (result.Success == ReadingStatus.Success) { logger.LogInformation("Successfully sent"); } else { logger.LogInformation("Failed to sent"); } await Task.Delay(this.config.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
public override async Task <StatusMessage> AddReading(ReadingPacket request, ServerCallContext context) { var result = new StatusMessage { Success = ReadingStatus.Failure }; if (request.Successful == ReadingStatus.Success) { try { foreach (var readingPack in request.Readings) { if (readingPack.ReadingValue < 1000) { _logger.LogDebug("Reading value below acceptable level"); var trailer = new Metadata() { { "BadValue", readingPack.ReadingValue.ToString() }, { "Field", "ReadingValue" }, { "Message", "Readings are invalid" } }; throw new RpcException(new Status(StatusCode.OutOfRange, "Value too low"), trailer); } var model = new MeterReading { CustomerId = readingPack.CustomerId, Value = readingPack.ReadingValue, ReadingDate = readingPack.ReadingTime.ToDateTime() }; _repositoryContext.AddEntity(model); } if (await _repositoryContext.SaveAllAsync()) { _logger.LogInformation($"Stored {request.Readings.Count} New Readings..."); result.Success = ReadingStatus.Success; } } catch (RpcException) { throw; } catch (Exception e) { _logger.LogError($"Exception thrown during the save meter readings: {e}"); throw new RpcException(Status.DefaultCancelled, "Exception thrown during the meter reading process"); } } return(result); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var customerId = _config.GetValue <int>("Service:CustomerId"); var packet = new ReadingPacket { Successful = ReadingStatus.Success, Notes = "This is a test" }; //var reading = new ReadingMessage //{ // CustomerId = customerId, // ReadingValue = 10000, // ReadingTime = Timestamp.FromDateTime(DateTime.UtcNow) //}; for (int x = 0; x < 5; ++x) { packet.Readings.Add(await _readingFactory.GenerateAsync(customerId)); } try { var result = await client.AddReadingAsync(packet); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Successfully sent"); } else { _logger.LogInformation("Failed to send"); } } catch (Exception ex) { Console.WriteLine(ex); } await Task.Delay(_config.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
public override Task <StatusMessage> AddReading(ReadingPacket request, ServerCallContext context) { var result = new StatusMessage { Status = ReadingStatus.Failure }; if (request.Status != ReadingStatus.Success) { return(Task.FromResult(result)); } try { foreach (var reading in request.Readings) { if (reading.ReadingValue < 1000) { _logger.LogDebug("Reading value is below acceptable value"); var trailer = new Metadata { { "BadValue", reading.ReadingValue.ToString() }, { "Field", nameof(reading.ReadingValue) }, { "Message", "Reading is invalid" } }; throw new RpcException(new Status(StatusCode.OutOfRange, "Value is too low"), trailer); } //save to db result.Status = ReadingStatus.Success; _logger.LogInformation($"Reading saved {JsonSerializer.Serialize(reading)}"); } } catch (RpcException) { throw; } catch (Exception e) { _logger.LogError($"Exception thrown during saving of readings: {e}"); throw new RpcException(Status.DefaultCancelled, e.Message); } return(Task.FromResult(result)); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); //await Task.Delay(1000, stoppingToken); // do something every second var customerId = _config.GetValue <int>("Service:CustomerId"); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is our test" }; for (var x = 0; x < 5; ++x) { pkt.Readings.Add(await _factory.Generate(customerId)); } //moved to ReadingFactory class //var reading = new ReadingMessage(); //reading.CustomerId = customerId; //reading.ReadingValue = 10000; //reading.ReadingTime = Timestamp.FromDateTime(DateTime.UtcNow); var result = await Client.AddReadingAsync(pkt); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Successfully sent"); } else { _logger.LogInformation("Failed to sent"); } await Task.Delay(_config.GetValue <int>("Service:DelayInterval"), stoppingToken); // do something every second} } }
public async override Task <StatusMessage> AddReading(ReadingPacket request, ServerCallContext context) { var result = new StatusMessage() { Success = ReadingStatus.Failure }; if (request.Successful == ReadingStatus.Success) { try { foreach (var r in request.Readings) { var reading = new MeterReading() { CustomerId = r.CustomerId, Value = r.ReadingValue, Time = r.ReadingTime.ToDateTime() }; _repository.AddEntity(reading); } if (await _repository.SaveAllAsync()) { _logger.LogInformation($"Stored {request.Readings.Count} new readings..."); result.Success = ReadingStatus.Success; } } catch (Exception ex) { result.Message = "Exception thrown during process"; _logger.LogError($"Expecion thrown during of reading {ex}"); } } return(await Task.FromResult(result)); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = new Random(); while (!stoppingToken.IsCancellationRequested) { counter++; if (counter % 10 == 0) { Console.WriteLine("Sending Diagnostics.."); var stream = Client.SendDiagnostics(); for (int i = 0; i < 5; i++) { var reading = await _factory.Generate(customerId.Next(1, 10000)); await stream.RequestStream.WriteAsync(reading); } await stream.RequestStream.CompleteAsync(); } _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is a nice test" }; for (int i = 0; i < _config.GetValue <int>("Service:Batch"); i++) { pkt.Readings.Add(await _factory.Generate(customerId.Next(1, 10000))); } try { var result = await Client.AddReadingAsync(pkt); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Succesfully sent"); } else { _logger.LogInformation("Failed to send"); } } catch (RpcException ex) { //_logger.LogError($"Exception thrown: {ex}"); // basic status error if (ex.StatusCode == StatusCode.OutOfRange) { _logger.LogError($"{ex.Trailers}"); } _logger.LogError($"Exception thrown: {ex}"); // custom status error } await Task.Delay(_config.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = _configuration.GetValue <int>("Service:CustomerId"); while (!stoppingToken.IsCancellationRequested) { counter++; if (counter % 10 == 0) { _logger.LogInformation("Sending diagnostics"); var stream = Client.SendDiagnostics(); for (var i = 0; i < 5; i++) { var reading = await _readingFactory.Generate(customerId); await stream.RequestStream.WriteAsync(reading); } await stream.RequestStream.CompleteAsync(); } var readingPacket = new ReadingPacket { Status = ReadingStatus.Success, Notes = "test" }; for (var i = 0; i < 5; i++) { readingPacket.Readings.Add(await _readingFactory.Generate(customerId)); } try { //for jwt //if (!NeedsLogin || await GenerateToken()) //{ // var headers = new Metadata {{"Authorization", $"Bearer {_token}"}}; // var result = await Client.AddReadingAsync(readingPacket, headers); // _logger.LogInformation(result.Status == ReadingStatus.Success // ? "Successfully sent" // : "Failed to send"); //} var result = await Client.AddReadingAsync(readingPacket); _logger.LogInformation(result.Status == ReadingStatus.Success ? "Successfully sent" : "Failed to send"); } catch (RpcException e) { if (e.StatusCode == StatusCode.OutOfRange) { _logger.LogError($" {e.Trailers}"); } _logger.LogError($"Exception thrown {e}"); } await Task.Delay(_configuration.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = _configuration.GetValue <int>("Service:CustomerId"); while (!stoppingToken.IsCancellationRequested) { counter++; //if (counter % 10 == 0) //{ // Console.WriteLine("Sending Diagnostics"); // var stream = Client.SendDiagnostics(); // for (int i = 0; i < 5; i++) // { // var readingRes = await _factory.Generate(customerId); // await stream.RequestStream.WriteAsync(readingRes); // } // await stream.RequestStream.CompleteAsync(); //} _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "This is our test" }; var reading = new ReadingMessage(); reading.CustomerId = customerId; reading.ReadingValue = 10000; reading.ReadingTime = Timestamp.FromDateTime(DateTime.UtcNow); for (int i = 0; i < 5; i++) { pkt.Readings.Add(await _factory.Generate(customerId)); } try { //if (!NeedsLogin() || await GenerateToken()) //{ // var headers = new Metadata(); // headers.Add("Authorization", $"Bearer {_token}"); var result = await Client.AddReadingAsync(pkt); // headers: headers); if (result.Successful == ReadingStatus.Success) { _logger.LogInformation("Successfully sent"); } else { _logger.LogInformation("Failed to send"); } //} } catch (RpcException ex) { if (ex.StatusCode == StatusCode.OutOfRange) { _logger.LogError($"{ex.Trailers}"); } _logger.LogError($"Exception Thrown: {ex}"); } await Task.Delay(_configuration.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var counter = 0; var customerId = _configuration.GetValue <int>("Service:CustomerId"); while (!stoppingToken.IsCancellationRequested) { counter++; //if (counter % 10 == 0) //{ // Console.WriteLine("Sending Diagnostics"); // var stream = Client.SendDiagnostics(); // for (int x = 0; x < 5; x++) // { // var reading = await _factory.Generate(customerId); // await stream.RequestStream.WriteAsync(reading); // } // //we finish writing to you // await stream.RequestStream.CompleteAsync(); //} _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); var pkt = new ReadingPacket() { Successful = ReadingStatus.Success, Notes = "this a test" }; for (int x = 0; x < 5; x++) { pkt.Readings.Add(await _factory.Generate(customerId)); } try { ////used only for JWT authentication //if (!NeedsLogin() || await GenerateToken()) //{ // var headers = new Metadata(); // headers.Add("Authorization", $"Bearer {_token}"); //var result = await Client.AddReadingAsync(pkt, headers: headers); var result = await Client.AddReadingAsync(pkt); if (result.Success == ReadingStatus.Success) { _logger.LogInformation("Successfully sent"); } else { _logger.LogError("Failed to send"); } //} } catch (RpcException e) { if (e.StatusCode == StatusCode.OutOfRange) { _logger.LogError($"{e.Trailers}"); } Console.WriteLine(e); throw; } await Task.Delay(_configuration.GetValue <int>("Service:DelayInterval"), stoppingToken); } }
public async override Task <StatusMessage> AddReading(ReadingPacket request, ServerCallContext context) { var result = new StatusMessage() { Success = ReadingStatus.Failure }; if (request.Successful == ReadingStatus.Success) { try { foreach (var r in request.Readings) { //---------test if (r.ReadingValue < 1000) { _logger.LogDebug("Reading Value below acceptable level"); //throw new RpcException(Status.DefaultCancelled, "Value too low.."); => basic status error #region custom status error var trailer = new Metadata() { { "BadValue", r.ReadingValue.ToString() }, { "Field", "ReadingValue" }, { "Message", "Readings are invalid" } }; throw new RpcException(new Status(StatusCode.OutOfRange, "Value too low")); // => custom status error #endregion } //---------test var reading = new MeterReading() { CustomerId = r.CustomerId, Value = r.ReadingValue, Time = r.ReadingTime.ToDateTime() }; _repository.AddEntity(reading); } if (await _repository.SaveAllAsync()) { _logger.LogInformation($"Stored {request.Readings.Count} new readings..."); result.Success = ReadingStatus.Success; } } //test catch (RpcException) { throw; } // catch (Exception ex) { _logger.LogError($"Expecion thrown during of reading {ex}"); throw new RpcException(Status.DefaultCancelled, "Exception thrown during process"); } } return(await Task.FromResult(result)); }