public override (double l1, double l2, double l3) Get()
{
var avg = _measurements.CalculateAggregatedAverageUsage();
if (avg.nrOfDataPoints < MinimumDataPoints)
{
return(-1, -1, -1);
}
Logger?.LogInformation($"avg current {avg.averageUsage} and charging at {avg.averageCharge}");
var chargeCurrent = Math.Round(LimitCurrentSolar(avg.averageCharge, avg.averageUsage), 2);
bool stateHasChanged;
if (chargeCurrent < MinimumChargeCurrent)
{
(chargeCurrent, stateHasChanged) = NotEnoughOverCapicity();
}
else
{
var t = AllowToCharge();
if (t.changed)
{
LoggerState?.Info($"charging {chargeCurrent}");
}
if (!t.allow)
{
chargeCurrent = 0.0f;
}
}
return((float)Math.Round(chargeCurrent, 2), 0, 0);
}
private void addImageAccordingToErrorLevel(LoggerState errorLevel, LogMessage @log)
{
if (errorLevel == LoggerState.INFORMATION)
{
string full = Path.GetFullPath(m_InformationImagePath);
log.Image = full;
}
if (errorLevel == LoggerState.WARNING)
{
string full = Path.GetFullPath(m_WarningImagePath);
log.Image = full;
}
if (errorLevel == LoggerState.ERROR)
{
string full = Path.GetFullPath(m_ErrorImagePath);
log.Image = full;
}
if (errorLevel == LoggerState.CRITICAL)
{
string full = Path.GetFullPath(m_CriticalImagePath);
log.Image = full;
}
}
static HospitalLogger()
{
Log = LogManager.GetLogger(typeof (HospitalLogger));
Logger = (log4net.Repository.Hierarchy.Logger) Log.Logger;
_loggerLevel = LoggerState.All;
AppendersTypes = new List<Type>();
}
static HospitalLogger()
{
Log = LogManager.GetLogger(typeof(HospitalLogger));
Logger = (log4net.Repository.Hierarchy.Logger)Log.Logger;
_loggerLevel = LoggerState.All;
AppendersTypes = new List <Type>();
}
public async Task Invoke(HttpContext context)
{
if (context == null)
{
throw new System.ArgumentNullException(nameof(context));
}
string correlationId = GetOrAddCorrelationHeader(context);
try
{
var loggerState = new LoggerState
{
[CORRELATION_ID_HEADER_NAME] = correlationId
//Add any number of properties to be logged under a single scope
};
using (_logger.BeginScope(loggerState))
{
await next(context);
}
}
//do not loose the scope in case of an unexpected error
catch (Exception ex) when(LogOnUnexpectedError(ex))
{
throw;
}
}
void Log(string message, LoggerState state = LoggerState.Info)
{
if (Logger != null)
{
Logger("ValueFinder", new AlgorithmLibEventArgs(state, message));
}
}
///<summary>
/// Logs message if the state provided matches its current state.
///</summary>
public void Log(string message, LoggerState state)
{
if ((state & CurrentState) != CurrentState || state == LoggerState.Silent)
{
return;
}
WriteTo.WriteLine(message);
}
public void Clear()
{
_startPosition = -Vector3.one;
_movingPiece = null;
_endPosition = -Vector3.one;
_capturedPiece = null;
_state = LoggerState.IDLE;
}
/// <summary>
/// Closes this logger.
/// </summary>
public static void Close()
{
if (state == LoggerState.Closed)
{
throw new InvalidOperationException("Can't close the log, because it is already closed!");
}
log.Close();
stream.Close();
state = LoggerState.Closed;
}
// public methods...
/// <summary>
/// Opens this logger using the given log file path.
/// </summary>
/// <param name="path">The path to the log file to use.</param>
public static void Open(string path)
{
if (state == LoggerState.Opened)
{
throw new InvalidOperationException("Can't open the log, because it is already opened!");
}
stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
log = new StreamWriter(stream);
state = LoggerState.Opened;
}
/// <summary>Begins logging.</summary>
public static void StartLogger()
{
if (currentLogger != null)
{
Destroy(currentLogger);
}
GameObject loggerObject = new GameObject("Performance Logger");
currentLogger = loggerObject.AddComponent <PerformanceLogger>();
CurrentState = LoggerState.Logging;
}
public void MapClassString()
{
Demo d = new Demo();
string test = "This is {ONE}. This is {TWO}. This is {THREEPOINT}";
string res = LoggerState.MergeObjectToString(d, test);
Debug.WriteLine(res);
Assert.IsTrue(res.Equals("This is 1. This is a toucan. This is 3.14"));
}
public void Log(string pLogMessage, LoggerState pErrorLevel)
{
// Propagate Log to GUI
if (m_ViewHandle != null)
{
LogMessage LogMessageT1 = new LogMessage();
LogMessageT1.Message = pLogMessage;
LogMessageT1.ErrorLevel = pErrorLevel;
addImageAccordingToErrorLevel(pErrorLevel, LogMessageT1);
this.m_AllLogsList.Add(LogMessageT1);
applyFilter();
}
switch (pErrorLevel)
{
case LoggerState.INFORMATION:
m_Writer.Write("\r\nINFORMATION: ");
m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
m_Writer.WriteLine(pLogMessage);
m_Writer.WriteLine("-------------------------------");
break;
case LoggerState.WARNING:
m_Writer.Write("\r\nWARNING: ");
m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
m_Writer.WriteLine(pLogMessage);
m_Writer.WriteLine("-------------------------------");
break;
case LoggerState.ERROR:
m_Writer.Write("\r\nERROR: ");
m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
m_Writer.WriteLine(pLogMessage);
m_Writer.WriteLine("-------------------------------");
break;
case LoggerState.CRITICAL:
m_Writer.Write("\r\nCRITICAL: ");
m_Writer.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
m_Writer.WriteLine(pLogMessage);
m_Writer.WriteLine("-------------------------------");
break;
default:
// TODO: do something smart here
break;
}
m_Writer.Flush();
}
public void LogMove(bool isCheck, bool isCheckMate)
{
if (_state != LoggerState.PREPARED)
{
throw new DragonChessException("Logger is in an illegal state");
}
_counter++;
StringBuilder sb = new StringBuilder();
sb.Append(_counter).Append(". ");
var movingPieceType = _movingPiece.GetType();
sb.Append(pieceCodes [movingPieceType]);
if (_endPosition.z != 1 || movingPieceType != Type.GetType("Dragon"))
{
sb.Append(GetPositionNotation(_startPosition));
}
if (_capturedPiece == null)
{
sb.Append("-");
}
else
{
sb.Append("x");
sb.Append(pieceCodes [_capturedPiece.GetType()]);
LogCapture();
}
sb.Append(GetPositionNotation(_endPosition));
if (movingPieceType == Type.GetType("Warrior") && _endPosition.y == 7)
{
sb.Append("(H)");
}
if (isCheckMate)
{
sb.Append(" mate");
}
else if (isCheck)
{
sb.Append(" ch");
}
Log.Add(sb.ToString());
Clear();
_state = LoggerState.IDLE;
}
/// <summary>
/// Log state changes
/// </summary>
private void SetState(LoggerState newState, string message, VoidVoid atomicOperation)
{
lock (this.stateLock)
{
Trace.WriteLine("SsmBasicLogger.SetState: invoked by " + message);
Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "SsmBasicLogger.SetState: from {0} to {1}", this.state, newState));
this.state = newState;
if (atomicOperation != null)
{
atomicOperation();
}
}
}
bool IXapLoggingProvider.Resume()
{
lock (this) {
// Fail if logging hasn't been paused
if (_loggerState != LoggerState.Paused)
{
return(false);
}
// Resume logging
_loggerState = LoggerState.Running;
return(true);
}
}
bool IXapLoggingProvider.Pause()
{
lock (this) {
// Fail if logging hasn't been started
if (_loggerState != LoggerState.Running)
{
return(false);
}
// Pause the logger
_loggerState = LoggerState.Paused;
return(true);
}
}
public static Exception WithState <TException>(this TException ex, LoggerState state) where TException : Exception
{
if (state != null)
{
var correlationId = ex.GetCorrelationId();
if (correlationId != Guid.Empty.ToString())
{
state.CorrelationId = correlationId;
}
ex.AddState(state);
}
return(ex);
}
public override (double l1, double l2, double l3) Get()
{
var avg = _measurements.CalculateAggregatedAverageUsage();
if (avg.nrOfDataPoints < MinimumDataPoints)
{
return(-1, -1, -1);
}
var chargeCurrent = Math.Round(LimitEco(avg.averageCharge, avg.averageUsage), 2);
Logger?.LogInformation($"avg current {avg.averageUsage} and avg charging at {avg.averageCharge}; limitted chargecurrent = {chargeCurrent} ({avg.nrOfDataPoints} datapoints (buffer size {MaxBufferSeconds} seconds)");
if ((_state.Current == ChargingState.Charging && chargeCurrent < MinimumEcoModeExportStop) ||
(_state.Current != ChargingState.Charging && chargeCurrent < MinimumEcoModeExportStart))
{
if (_state.Current == ChargingState.Charging)
{
_state.Pause();
LoggerState.Info($"Charging state pause {chargeCurrent}");
}
return(0, 0, 0);
}
else
{
var t = AllowToCharge();
if (t.allow)
{
// charge as fast as possible and as close to the current available capicity as possible
var avgShort = _measurements.CalculateAggregatedAverageUsage(DateTimeProvider.Now.AddSeconds(-10));
var chargeCurrentShort1 = Math.Round(LimitEco(avgShort.averageCharge, avgShort.averageUsage), 2);
Logger?.LogInformation($"charging {chargeCurrent} -> {chargeCurrentShort1}");
if (t.changed)
{
LoggerState?.Info($"charging {chargeCurrent} -> {chargeCurrentShort1}");
}
return((float)Math.Round(chargeCurrentShort1, 2), 0, 0);
}
else
{
Logger?.LogInformation($"charging {chargeCurrent} -> not yet allowed");
return(0, 0, 0);
}
}
}
/*
* In case of error during uprading return a modified nuget package
* assume that that everything that should be removed is still there
* in case of upgrade it might be harder because we can not be sure what happend before.
* but the deployment action must handle this!
*/
public void Upgrade(string packageId, Version packageVersion, string packageDownloadUri)
{
var loggerstate = new LoggerState
{
{ nameof(packageId), packageId },
{ nameof(packageVersion), packageVersion },
{ nameof(packageDownloadUri), packageDownloadUri },
};
logger.LogInformation("Upgrading package '{0}' to version '{1}'", packageId, packageVersion);
using (logger.BeginScope(loggerstate))
{
PerformanceLogger performanceLogger = new PerformanceLogger(logger);
logger.LogInformation("Starting action on package xml list.");
performanceLogger.Restart("Starting action on package xml list.");
packageListRepository.StartActionOnPackage(packageId, packageVersion);
performanceLogger.Stop();
logger.LogInformation("Installing new package.");
performanceLogger.Restart("Installing new package.");
NugetPackage upgradePackage = nugetPackageRepository.InstallPackage(packageId, packageVersion, packageDownloadUri);
performanceLogger.Stop();
logger.LogInformation("Reading installed package.");
performanceLogger.Restart("Reading installed package.");
NugetPackage installedPackage = nugetPackageRepository.ReadInstalledPackage(packageId);
logger.LogInformation("Installed Package: {0}", installedPackage?.PackageIdentifier);
performanceLogger.Stop();
logger.LogInformation("Upgrading package.");
performanceLogger.Restart("Upgrading package.");
upgradePackage.Upgrade(logger, deploymentComponentFactory, installedPackage);
performanceLogger.Stop();
logger.LogInformation("Archiving package.");
performanceLogger.Restart("Archiving package.");
nugetPackageRepository.ArchivePackage(packageId);
performanceLogger.Stop();
logger.LogInformation("Ending action on package xml list.");
performanceLogger.Restart("Ending action on package xml list.");
packageListRepository.EndActionOnPackage(packageId, packageVersion);
performanceLogger.Stop();
}
}
public override (double l1, double l2, double l3) Get()
{
var avg = _measurements.CalculateAverageUsage();
if (avg.NrOfDataPoints < MinimumDataPoints)
{
return(-1, -1, -1);
}
LoggerState.Info($"avg current {avg.CurrentUsingL1}, {avg.CurrentUsingL2} , {avg.CurrentUsingL3}");
var retval1 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL1, avg.CurrentUsingL1), 2);
var retval2 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL2, avg.CurrentUsingL2), 2);
var retval3 = (float)Math.Round(LimitCurrent(avg.CurrentChargingL3, avg.CurrentUsingL3), 2);
Logger?.LogInformation($"{(float)Math.Round(avg.CurrentUsingL1, 2)}, {(float)Math.Round(avg.CurrentUsingL2, 2)}, {(float)Math.Round(avg.CurrentUsingL3, 2)} => {retval1}, {retval2}, {retval3}");
return(retval1, retval2, retval3);
}
public void PrepareMove(Vector3 start, Vector3 end, Board[] boards)
{
if (_state != LoggerState.IDLE)
{
throw new DragonChessException("Logger is in an illegal state");
}
_startPosition = start;
_movingPiece = boards [(int)start.z] [(int)start.x, (int)start.y].Piece.GetComponent <Piece> ();
_endPosition = end;
var capturedPieceObj = boards [(int)end.z] [(int)end.x, (int)end.y].Piece;
if (capturedPieceObj != null)
{
_capturedPiece = capturedPieceObj.GetComponent <Piece> ();
}
_state = LoggerState.PREPARED;
}
/// <summary>Ends the logger, dumping to a logfile.</summary>
/// <param name="path">Full name and path of the logfile to dump to.</param>
/// <param name="extraInfo">Any extra information to prepend to the logfile.</param>
/// <param name="async">If the dump process should run in asynchronous mode.</param>
/// <param name="completionCallback">An optional callback to execute upon completing the log dump.</param>
public static void EndLogger(string path, string extraInfo = "", bool async = true, Action completionCallback = null)
{
if (currentLogger == null)
{
Debug.LogError("ERROR: No logger was running");
}
else
{
CurrentState = LoggerState.Dumping;
if (async)
{
//Ends logger, begins asynchronous dump, completing all main thread only tasks before entering async mode
currentLogger.completionCallback = completionCallback;
if (openLogFolder)
{
if (completionCallback == null)
{
currentLogger.completionCallback = () => ShowLogFolder(path);
}
else
{
currentLogger.completionCallback += () => ShowLogFolder(path);
}
}
currentLogger.GetSystemSpecs();
Thread dumpThread = new Thread(new ThreadStart(() => currentLogger.DumpLog(path, extraInfo)));
dumpThread.IsBackground = true;
dumpThread.Start();
}
else
{
//Dumps logfile and ends logger
currentLogger.DumpLog(path, extraInfo);
completionCallback();
if (openLogFolder)
{
ShowLogFolder(path);
}
Destroy(currentLogger.gameObject);
currentLogger = null;
}
}
}
bool IXapLoggingProvider.Stop()
{
lock (this) {
// Fail if logging hasn't been started
if (_loggerState != LoggerState.Running)
{
return(false);
}
// Stop logging
try {
_logFile.Close();
_logFile = null;
} catch {
return(false);
}
_loggerState = LoggerState.Stopped;
return(true);
}
}
public static void AddState <TException>(this TException ex, LoggerState state) where TException : Exception
{
if (ex != null)
{
var mergeState = state;
if (ex.Data.Contains(ExceptionStateKey))
{
var prevState = ex.Data[ExceptionStateKey] as LoggerState;
if (prevState != null)
{
mergeState = prevState.MergedWith(state);
}
}
if (mergeState != null)
{
ex.Data[ExceptionStateKey] = mergeState;
}
}
}
/// <summary>
/// A operação Shutdown bloqueia a thread invocante até que todos os relatórios submetidos até ao momento sejam efectivamente
/// escritos; relatórios submetidos posteriormente são rejeitados (i.e. chamadas a LogMessage produzem excepção).
/// </summary>
public void Shutdown()
{
lock (this)
{
_state = LoggerState.Shutdown;
if (_msgQueue.Count == 0)
{
_myTw.Close();
return;
}
do
{
// try
// {
Monitor.Wait(this);
// }
// catch (ThreadInterruptedException)
// {
// foreach (var msg in _msgQueue)
// {
// _msgQueue.Remove(msg);
// }
// throw;
// }
if (_msgQueue.Count == 0)
{
_myTw.Close();
return;
}
} while (true);
}
}
private static void LogPrefix(LoggerState state)
{
if (state == LoggerState.Success)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("[Success] ");
}
else if (state == LoggerState.Failure)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("[Failure] ");
}
else if (state == LoggerState.Warning)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write("[Warning] ");
}
else if (state == LoggerState.Informational)
{
Console.Write("[Information] ");
}
Console.ForegroundColor = ConsoleColor.White;
}
///<summary>Sets logger state, and by default writes to Console.Out(stdout).</summary>
public Logger(LoggerState state)
{
CurrentState = state;
WriteTo = Console.Out;
}
public AlgorithmLibEventArgs(LoggerState _state, string _mesage)
{
message = _mesage;
state = _state;
}
///<summary>
/// Sets logger state.
///</summary>
public static void UseLogger(LoggerState state)
{
logger.CurrentState = state;
}
/// <summary>
/// Log state changes
/// </summary>
private void SetState(LoggerState newState, string message)
{
this.SetState(newState, message, null);
}
protected virtual bool StartLog(IXapLoggingContext loggingContext)
{
if (string.IsNullOrWhiteSpace(loggingContext.LogFileLocation))
{
_logFilename = XapEnvironment.Instance.MapFolderPath(XapConfig.Instance.GetValue <string>($"{XapEnvironment.Instance.EnvironmentName}.logging", "logFile"));
}
else
{
_logFilename = loggingContext.LogFileLocation;
}
_bAppend = loggingContext.AppendToLog;
_levels = loggingContext.LoggingLevel;
lock (this) {
// Fail if logging has already been started
if (_loggerState != LoggerState.Stopped)
{
return(false);
}
// Fail if the log file isn't specified
if (String.IsNullOrEmpty(_logFilename))
{
return(false);
}
// Delete log file if it exists
if (!_bAppend)
{
try {
File.Delete(_logFilename);
} catch (Exception) {
return(false);
}
}
// Open file for writing - return on error
if (!File.Exists(_logFilename))
{
try {
_logFile = File.CreateText(_logFilename);
} catch (Exception) {
_logFile = null;
return(false);
}
}
else
{
try {
_logFile = File.AppendText(_logFilename);
} catch {
_logFile = null;
return(false);
}
}
_logFile.AutoFlush = true;
// Return successfully
_loggerState = LoggerState.Running;
return(true);
}
}
/// <summary>
/// A classe inclui ainda as operações Start e Shutdown que promovem o início e a terminação do
/// registo de relatórios, respectivamente.
/// </summary>
public void Start()
{
_state = LoggerState.Working;
_loggerThread = new Thread((msg) =>
{
lock (this)
{
LinkedListNode<string> myNode = new LinkedListNode<string>(((string) msg));
_msgQueue.AddLast(myNode);
do
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
_msgQueue.Remove(myNode);
throw;
}
if (_msgQueue.First == myNode)
{
// TODO : Comparar a thread actual com a loggerthread (priority), NOT FINISHED! (Não faz sentido!!)
if (Thread.CurrentThread.Priority < _loggerThread.Priority)
{
_myTw.Write(msg);
Monitor.PulseAll(this);
}
}
} while (true);
}
});
_loggerThread.Priority = ThreadPriority.BelowNormal;
}
public void Shutdown()
{
lock (this)
{
if (_state == LoggerState.SHUTDOWN)
return;
_state = LoggerState.SHUTDOWN;
do
{
// Esperar pelo fim de todas as escritas
if (messagesToWrite.Count == 0)
{
_writer.Close();
return;
}
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException iex)
{
_writer.Close();
throw;
}
} while (true);
}
}
public Ex5Logger(TextWriter tw)
{
_msgQueue = new LinkedList<string>();
_myTw = tw;
_state = LoggerState.NotStarted;
}
public Ex5Logger(TextWriter writer)
{
messagesToWrite = new LinkedList<MsgSenderThread>();
_state = LoggerState.NOT_ACTIVE;
_writer = writer;
}
public void Start()
{
_loggerThread = new Thread( () =>
{
lock (this)
{
if (_state == LoggerState.NOT_ACTIVE)
_state = LoggerState.ACTIVE;
do
{
if (messagesToWrite.Count>0)
{
foreach(MsgSenderThread msgNode in messagesToWrite){
if(!msgNode.Processed){
_writer.WriteLine(msgNode.Msg);
msgNode.Processed = true;
Monitor.PulseAll(this); // Notificar threads, para elas verem se a sua msg ja foi escrita no ficheiro
}
}
}
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException iex)
{
foreach (MsgSenderThread msg in messagesToWrite)
messagesToWrite.Remove(msg);
Monitor.PulseAll(this);
}
} while (true);
}
});
_loggerThread.Priority = ThreadPriority.Lowest;
_state = LoggerState.ACTIVE;
_loggerThread.Start();
}
