public void GetByAppId_with_valid_id()
{
// arrange
var log = NewLogRepo();
var logentry = new ResponseLog()
{
AppId = DefaultAppId,
ByteSent = 234,
CreatedOn = DateTime.UtcNow,
HanlderExeTime = 345,
ResponseTime = 456,
MachineName = "mname-1",
RawUrl = "rurl-1",
Url = "url-1",
Scale = Size.KB,
TimeScale = TimeSlice.Milliseconds
};
log.Log(logentry);
// act
var actual = log.GetByAppId(DefaultAppId);
// assert
Assert.NotNull(actual);
Assert.NotEmpty(actual);
Assert.True(actual.First().MachineName == "mname-1");
}
public void GetByAppId_for_valid_from_to_has_no_logentries()
{
// arrange
var log = NewLogRepo();
var logentry = new ResponseLog()
{
AppId = DefaultAppId,
ByteSent = 234,
CreatedOn = DateTime.Parse("2017-09-26"),
HanlderExeTime = 345,
ResponseTime = 456,
MachineName = "mname-1",
RawUrl = "rurl-1",
Url = "url-1",
Scale = Size.KB,
TimeScale = TimeSlice.Milliseconds
};
log.Log(logentry);
var rf = DateTime.Parse("2018-09-25");
var another = logentry.DeepCopy();
another.CreatedOn = rf;
log.Log(another);
// act
var actual = log.GetByAppId(DefaultAppId, rf.AddYears(10), rf.AddYears(11));
// assert
Assert.Null(actual);
}
public Log(string id, string teamId, IReadOnlyCollection <string> stubIds, RequestLog request,
ResponseLog response, DateTime loggedAt)
{
Id = id;
TeamId = teamId;
StubIds = stubIds;
Request = request;
Response = response;
LoggedAt = loggedAt;
}
public async Task Invoke(HttpContext context)
{
RequestLog requestLog = await LogRequest(context);
_logger.LogInformation(requestLog.ToString());
ResponseLog responseLog = await LogResponse(context);
_logger.LogInformation(responseLog.ToString());
}
private void ExecuteMDI(string command)
{
if (!string.IsNullOrEmpty(command) && ApplyCommand(command))
{
if (command.Length > 1)
{
CommandLog.Add(command);
ResponseLog.Add(command);
}
}
}
public void ExecuteCommand(string command)
{
if (!string.IsNullOrEmpty(command))
{
MDI = command;
if (ResponseLogVerbose)
{
ResponseLog.Add(command);
}
}
}
public IEnumerator RequestLogCount()
{
var url = "loginbonus/log_count";
HttpClient client = new HttpClient();
yield return(App.Util.SceneManager.CurrentScene.StartCoroutine(client.Send(url)));
ResponseLog response = client.Deserialize <ResponseLog>();
this.count = response.count;
}
public void LogResponse(ResponseLog response)
{
ConvertResponseLog data = new ConvertResponseLog
{
RequestId = response.RequestId,
ResponseDateUtc = response.ResponseDateUtc,
ResultFileSize = response.ResultFileSize,
ResultType = response.ErrorType.ToResultType()
};
new CreateConvertResponseLog(this.convertLogRepository).Execute(data);
}
public void Save(GoCanvasLoggingDbContext dbContext)
{
if (HasXMLBody)
{
var record = new ResponseLog()
{
ResponseBody = $"{this.ToString()}"
};
try
{
MemoryStream ms = new MemoryStream();
this.Request.Body.Seek(0, SeekOrigin.Begin);
this.Request.Body.CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
var xmlSerializer = new XmlSerializer(typeof(SubmissionNotification));
SubmissionNotification submission_notification = (SubmissionNotification)xmlSerializer.Deserialize(ms);
}
catch (Exception e)
{
record.ResponseType = 1;
}
try
{
dbContext.ResponseLogs.Add(record);
dbContext.SaveChanges();
}
catch (Exception e)
{
using (dbContext.Database.BeginTransaction(IsolationLevel.Unspecified))
{
dbContext.Database.ExecuteSqlRaw($"INSERT INTO [tblResponseLog]([ResponseBody])VALUES('ResponseBody Logger FAILED::{e}|{this.ToString()}');");
}
try
{
using (dbContext.Database.BeginTransaction(IsolationLevel.Unspecified))
{
dbContext.Database.ExecuteSqlRaw($"INSERT INTO [tblResponseLog]([ResponseBody])VALUES('{this.ToString()}');");
}
}
catch (Exception exception)
{
using (dbContext.Database.BeginTransaction(IsolationLevel.Unspecified))
{
dbContext.Database.ExecuteSqlRaw($"INSERT INTO [tblResponseLog]([ResponseBody])VALUES('ResponseBody Logger FAILED::{e}|{this.ToString()}');");
}
}
}
}
}
private void LogHttpResponse(LogRequestAndResponseCommand command, LogDbContext db)
{
var responseLog = new ResponseLog
{
RequestGuid = command.RequestGuid,
ResponseId = command.RequestTime.Ticks,
DateTimeUtc = this.ResponseTime,
Status = $"HTTP {this.StatusCode}",
Exception = this.Exception
};
db.ResponseLogs.Add(responseLog);
db.SaveChanges();
}
public void SendResponse(IPCMessage message)
{
lock (ResponseQueue)
lock (ResponseLog)
{
if (ResponseQueue.ContainsKey(message.Id) || ResponseLog.ContainsKey(message.Id))
{
// Repeated response
return;
}
ResponseQueue.Add(message.Id, message);
}
}
public AppResponseTime UpdateAndGet(ResponseLog log, out AppResponseSize responseSize)
{
if (log == default(ResponseLog))
{
throw new ArgumentNullException(nameof(log));
}
var rtn = _appResponse.UpdateRecentByAppId(log.AppId, log.ResponseTime);
responseSize = _appSize.UpdateRecentByAppId(log.AppId, log.ByteSent);
_log.Log(log);
return(rtn);
}
public void ExecuteCommand(string command)
{
if (command != null)
{
MDI = command;
if (command == string.Empty)
{
SetGrblError(0);
}
if (ResponseLogVerbose && !string.IsNullOrEmpty(command))
{
ResponseLog.Add(command);
}
}
}
private static async Task <string> FormatResponse(HttpResponse httpResponse, MemoryStream responseStream)
{
var buffer = new byte[responseStream.Length];
responseStream.Seek(0, SeekOrigin.Begin);
await responseStream.ReadAsync(buffer, 0, buffer.Length);
responseStream.Seek(0, SeekOrigin.Begin);
var bodyAsText = Encoding.UTF8.GetString(buffer);
var responseLog = new ResponseLog
{
Body = JsonConvert.DeserializeObject(bodyAsText),
StatusCode = httpResponse.StatusCode
};
return(Regex.Unescape(JsonConvert.SerializeObject(responseLog, Formatting.Indented)));
}
public void LogResponseData(HttpApplication app)
{
app = app ?? throw new ArgumentNullException(nameof(app));
// Calculate the response time from response start time
var rt = DateTime.Now.AspNetInsightNow() - app.Context.Timestamp.AspNetInsightNow();
app.Context.Items.Add(InstrumentKeys._t_Response, rt);
// Collect raw url
var url = app.Request.RawUrl;
// Get response size data
var wrapper = app.Response.Filter as ResponseStreamWrapper;
var byt = wrapper.Size;
// Get App info
CurrentApp = CurrentApp ?? Init();
// form tracking data
ResponseLog log = new ResponseLog()
{
AppId = CurrentApp.Id,
ByteSent = byt,
CreatedOn = DateTime.Now.AspNetInsightNow(),
HanlderExeTime = Convert.ToDouble(app.Context.Items[InstrumentKeys._t_Handlder]),
MachineName = CurrentApp.MachineName,
RawUrl = url,
ResponseTime = rt.TotalMilliseconds,
Scale = Size.Byte,
TimeScale = TimeSlice.Milliseconds,
Url = CurrentApp.Url
};
// Log and get min, avg, max ..etc
var time = _responseIntru.UpdateAndGet(log, out AppResponseSize size);
// Generates the html widget data
if (_config.ShowBanner)
{
app.Context.Items.Add(InstrumentKeys._response_Banner, GenerateBanner(time, size));
}
}
public void Log_with_valid_data()
{
// arrange
var log = NewLogRepo();
var logentry = new ResponseLog()
{
AppId = DefaultAppId,
ByteSent = 234,
CreatedOn = DateTime.UtcNow,
HanlderExeTime = 345,
ResponseTime = 456,
MachineName = "mname-1",
RawUrl = "rurl-1",
Url = "url-1", Scale = Size.KB, TimeScale = TimeSlice.Milliseconds
};
// act and assert
Assert.DoesNotThrow(() => log.Log(logentry));
}
public static Task<string> Save(string method, Uri requestUrl, Dictionary<string, string> parameters, string response)
{
return Task.Run(() =>
{
var logObj = new ResponseLog()
{
Method = method,
RequestUrl = requestUrl,
Parameters = parameters,
Response = response,
};
if (logDir.Exists == false)
logDir.Create();
var path = string.Format("{0}\\{1}.xml", logDir.FullName, GetHash(logObj.Method, logObj.RequestUrl, logObj.Parameters));
using (var fileStrm = new System.IO.FileStream(path, System.IO.FileMode.Create, System.IO.FileAccess.Write))
_seri.WriteObject(fileStrm, logObj);
return path;
});
}
public IPCMessage GetResponse(Guid responseId)
{
lock (ResponseQueue)
lock (ResponseLog)
{
if (ResponseQueue.ContainsKey(responseId))
{
IPCMessage response = ResponseQueue[responseId];
ResponseQueue.Remove(responseId);
ResponseLog.Add(responseId, response);
return(response);
}
else if (ResponseLog.ContainsKey(responseId))
{
IPCMessage response = ResponseLog[responseId];
return(response);
}
else
{
return(null);
}
}
}
public void DataReceived(string data)
{
if (data.Length == 0)
{
return;
}
if (ResponseLogVerbose || !(data.First() == '<' || data.First() == '$' || data.First() == 'o') || data.StartsWith("error"))
{
if (!(data.First() == '<' && ResponseLogFilterRT))
{
ResponseLog.Add(data);
if (ResponseLog.Count > 200)
{
ResponseLog.RemoveAt(0);
}
}
}
if (data.First() == '<')
{
ParseStatus(data);
OnRealtimeStatusProcessed?.Invoke(data);
}
else if (data.StartsWith("ALARM"))
{
string[] alarm = data.Split(':');
SetGRBLState("Alarm", alarm.Length == 2 ? int.Parse(alarm[1]) : -1, false);
}
else if (data.StartsWith("["))
{
switch (data.Substring(1, data.IndexOf(':') - 1))
{
case "PRB":
ParseProbeStatus(data);
break;
case "GC":
ParseGCStatus(data);
break;
case "TLR":
TloReference = dbl.Parse(data.Substring(5).TrimEnd(']'));
break;
case "TLO":
// Workaround for legacy grbl, it reports only one offset...
ToolOffset.SuspendNotifications = true;
ToolOffset.Z = double.NaN;
ToolOffset.SuspendNotifications = false;
// End workaround
ToolOffset.Parse(data.Substring(5).TrimEnd(']'));
// Workaround for legacy grbl, copy X offset to Z (there is no info available for which axis...)
if (double.IsNaN(ToolOffset.Z))
{
ToolOffset.Z = ToolOffset.X == 0 ? double.NaN : ToolOffset.X;
ToolOffset.X = double.NaN;
OnPropertyChanged(nameof(IsToolOffsetActive));
}
// End workaround
break;
case "HOME":
ParseHomedStatus(data);
break;
case "MSG":
Message = data == "[MSG:]" ? string.Empty : data;
if (data == "[MSG:Pgm End]")
{
ProgramEnd = true;
}
break;
}
}
else if (data.StartsWith("Grbl"))
{
if (Poller != null)
{
Poller.SetState(0);
}
_grblState.State = GrblStates.Unknown;
GrblReset = true;
OnGrblReset?.Invoke();
_reset = false;
}
else if (_grblState.State != GrblStates.Jog)
{
if (data == "ok")
{
OnCommandResponseReceived?.Invoke(data);
}
else
{
if (data.StartsWith("error:"))
{
try
{
SetGrblError(int.Parse(data.Substring(6)));
}
catch
{
}
OnCommandResponseReceived?.Invoke(data);
}
else if (!data.StartsWith("?"))
{
// Message = data; //??
}
}
}
OnResponseReceived?.Invoke(data);
}
protected virtual JobInfo AddJobInternal(Guid?sessionId, IFormFile file)
{
Guid jobId = Guid.NewGuid();
if (this.logService != null)
{
RequestLog requestLog = new RequestLog
{
RequestId = jobId,
RequestDateUtc = DateTime.UtcNow,
SenderIp = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
FileExtension = Path.GetExtension(file.FileName),
FileSize = (int)file.Length,
CustomAttributes = null
};
this.logService.LogRequest(requestLog);
}
byte[] inFileBytes = new byte[file.Length];
using (Stream stream = file.OpenReadStream())
{
stream.Read(inFileBytes, 0, (int)file.Length);
}
byte[] outFileBytes = null;
Exception convertException = null;
try
{
outFileBytes = this.converter.Convert(inFileBytes, Path.GetExtension(file.FileName));
}
catch (Exception e)
{
convertException = e;
}
if (this.logService != null)
{
ResponseLog responseLog = new ResponseLog
{
RequestId = jobId,
ResponseDateUtc = DateTime.UtcNow,
ResultFileSize = outFileBytes?.Length,
ErrorType = convertException?.ToConvertErrorType()
};
this.logService.LogResponse(responseLog);
}
{
StorageFile inputFile = file.ToStorageFile();
StorageFile outputFile = (convertException != null) ? null : new StorageFile
{
FileId = Guid.NewGuid(),
FileName = Path.GetFileNameWithoutExtension(file.FileName) + ".pdf",
FileSize = outFileBytes.Length,
CreateDateUtc = DateTime.UtcNow,
Bytes = outFileBytes
};
Job job = new Job
{
JobId = jobId,
ExpireDateUtc = (this.options?.FileLifeTime == null) ? (DateTime?)null : DateTime.UtcNow.Add(options.FileLifeTime),
SessionId = sessionId,
Rating = null,
InputFileId = inputFile.FileId,
OutputFileId = outputFile?.FileId,
ErrorType = convertException?.ToConvertErrorType()
};
this.fileService.AddFile(inputFile);
if (outputFile != null)
{
this.fileService.AddFile(outputFile);
}
this.jobService.AddJob(job);
return(job.ToJobInfo(inputFile, outputFile));
}
}
public ConvertResponseMessage Convert(MessageContracts.Converter.V1.ConvertMessage message)
{
Guid requestId = Guid.NewGuid();
if (this.logger != null)
{
RemoteEndpointMessageProperty endpointProperty =
OperationContext.Current.IncomingMessageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
RequestLog requestLog = new RequestLog
{
RequestId = requestId,
RequestDateUtc = DateTime.UtcNow,
SenderIp = endpointProperty.Address,
FileExtension = message.FileExtension,
FileSize = message.FileBytes.Length,
CustomAttributes = message.CustomAttributes?.ToDictionary(p => p.Name, p => p.Value)
};
this.logger.LogRequest(requestLog);
}
byte[] fileBytes = null;
Exception convertException = null;
try
{
fileBytes = this.converter.Convert(message.FileBytes, message.FileExtension);
}
catch (Exception e)
{
convertException = e;
}
if (this.logger != null)
{
ResponseLog responseLog = new ResponseLog
{
RequestId = requestId,
ResponseDateUtc = DateTime.UtcNow,
ResultFileSize = fileBytes?.Length,
ErrorType = convertException.ToConvertErrorType()
};
this.logger.LogResponse(responseLog);
}
if (convertException == null)
{
return(new ConvertResponseMessage
{
RequestId = requestId,
FileBytes = fileBytes
});
}
else
{
FaultException fault;
try
{
fault = convertException.ToV1FaultConverter();
}
catch (NotSupportedException)
{
throw convertException;
}
throw fault;
}
}
public void DataReceived(string data)
{
if (data.Length == 0)
{
return;
}
if (SuspendProcessing)
{
OnResponseReceived?.Invoke(data);
return;
}
if (ResponseLogVerbose || !(data.First() == '<' || data.First() == '$' || data.First() == 'o' || (data.First() == '[' && DataIsEnumeration(data))) || data.StartsWith("error"))
{
if (!(data.First() == '<' && ResponseLogFilterRT))
{
if (data.StartsWith("error:"))
{
var msg = GrblErrors.GetMessage(data.Substring(6));
ResponseLog.Add(data + (msg == data ? "" : " - " + msg));
}
else if (!ResponseLogFilterOk || data != "ok")
{
ResponseLog.Add(data);
}
if (ResponseLog.Count > 200)
{
ResponseLog.RemoveAt(0);
}
}
}
if (data.First() == '<')
{
ParseStatus(data);
OnRealtimeStatusProcessed?.Invoke(data);
}
else if (data.StartsWith("ALARM"))
{
string[] alarm = data.Split(':');
SetGRBLState("Alarm", alarm.Length == 2 ? int.Parse(alarm[1]) : -1, false);
}
else if (data.StartsWith("["))
{
switch (data.Substring(1, data.IndexOf(':') - 1))
{
case "PRB":
ParseProbeStatus(data);
break;
case "GC":
ParseGCStatus(data);
break;
case "TLR":
TloReference = dbl.Parse(data.Substring(5).TrimEnd(']'));
break;
case "TLO":
// Workaround for legacy grbl, it reports only one offset...
ToolOffset.SuspendNotifications = true;
ToolOffset.Z = double.NaN;
ToolOffset.SuspendNotifications = false;
// End workaround
ToolOffset.Parse(data.Substring(5).TrimEnd(']'));
// Workaround for legacy grbl, copy X offset to Z (there is no info available for which axis...)
if (double.IsNaN(ToolOffset.Z))
{
ToolOffset.Z = ToolOffset.X;
ToolOffset.X = ToolOffset.Y = 0d;
OnPropertyChanged(nameof(IsToolOffsetActive));
}
GrblWorkParameters.ToolLengtOffset.Z = ToolOffset.Z;
// End workaround
break;
case "HOME":
ParseHomedStatus(data);
break;
case "MSG":
data = data.Substring(5).Trim().TrimEnd(']');
if (data == "'$H'|'$X' to unlock")
{
Message = GrblInfo.IsGrblHAL ? "<Unlock> to continue" : "<Home> or <Unlock> to continue";
}
else if (GrblState.State == GrblStates.Alarm && data != "Caution: Unlocked")
{
switch (GrblState.Substate)
{
case 10:
_message = "clear then <Reset> then <Unlock> to continue";
break;
case 11:
_message = "<Home> to continue";
break;
default:
_message = "<Reset> then <Unlock> to continue";
break;
}
Message = (data == "Reset to continue" ? string.Empty : data + ", ") + _message;
}
else
{
Message = data;
}
if (data == "Pgm End")
{
ProgramEnd = true;
}
break;
}
}
else if (data.StartsWith("Grbl"))
{
if (Poller != null)
{
Poller.SetState(0);
}
_grblState.State = GrblStates.Unknown;
var msg = Message;
GrblReset = true;
OnGrblReset?.Invoke(data);
Message = msg;
_reset = false;
}
else if (_grblState.State != GrblStates.Jog)
{
if (data == "ok")
{
OnCommandResponseReceived?.Invoke(data);
}
else
{
if (data.StartsWith("error:"))
{
try
{
SetGrblError(int.Parse(data.Substring(6)));
}
catch
{
}
OnCommandResponseReceived?.Invoke(data);
}
else if (!data.StartsWith("?"))
{
// Message = data; //??
}
}
}
OnResponseReceived?.Invoke(data);
}
public void DataReceived(string data)
{
if (data.Length == 0)
{
return;
}
if (ResponseLogVerbose || !(data.First() == '<' || data.First() == '$' || data.First() == 'o') || data.StartsWith("error"))
{
ResponseLog.Add(data);
if (ResponseLog.Count > 200)
{
ResponseLog.RemoveAt(0);
}
}
if (data.First() == '<')
{
ParseStatus(data);
OnRealtimeStatusProcessed?.Invoke(data);
}
else if (data.StartsWith("ALARM"))
{
string[] alarm = data.Split(':');
SetGRBLState("Alarm", alarm.Length == 2 ? int.Parse(alarm[1]) : -1, false);
}
else if (data.StartsWith("[PRB:"))
{
ParseProbeStatus(data);
}
else if (data.StartsWith("[GC:"))
{
ParseGCStatus(data);
}
else if (data.StartsWith("[TLO:"))
{
ToolOffset.Parse(data);
}
else if (data.StartsWith("["))
{
if (data.StartsWith("[MSG:"))
{
Message = data == "[MSG:]" ? string.Empty : data;
if (data == "[MSG:Pgm End]")
{
ProgramEnd = true;
}
} // else ignore?
}
else if (data.StartsWith("Grbl"))
{
GrblReset = true;
_grblState.State = GrblStates.Unknown;
OnGrblReset?.Invoke();
_reset = false;
}
else if (_grblState.State != GrblStates.Jog)
{
if (data == "ok")
{
OnCommandResponseReceived?.Invoke(data);
}
else
{
if (data.StartsWith("error:"))
{
try
{
SetGrblError(int.Parse(data.Substring(6)));
}
catch
{
}
OnCommandResponseReceived?.Invoke(data);
}
else if (!data.StartsWith("?"))
{
// Message = data; //??
}
}
}
OnResponseReceived?.Invoke(data);
}
