private static void CreateIndex(ICodeSearcherLogic logic)
{
logic.CreateNewIndex(() =>
{
ShowCreateNewIndexHeader();
},
(name) =>
{
AsyncLogger.WriteLine(name);
},
(fileCount, timeSpan) =>
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WriteLine();
Console.WriteLine(">> building search index finished!");
Console.WriteLine("{0} files indexed", fileCount);
Console.WriteLine(">> action take : {0:00}:{1:00}:{2:00}.{3:000}",
timeSpan.Hours,
timeSpan.Minutes,
timeSpan.Seconds,
timeSpan.Milliseconds);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
});
}
public void AddPackageImages(PackageImages objPackageImages)
{
try
{
_logger.addMessage.Add("AddPackageImages", "AddPackageImages Method is going to Execute");
Dictionary <string, object> objparamlist = new Dictionary <string, object>();
_logger.addMessage.Add("CompanyID", objPackageImages.CompanyID);
objparamlist.Add("CompanyID", objPackageImages.CompanyID);
_logger.addMessage.Add("PackageCode", objPackageImages.PackageCode);
objparamlist.Add("PackageCode", objPackageImages.PackageCode);
_logger.addMessage.Add("PackageImageName", objPackageImages.PackageImageName);
objparamlist.Add("PackageImageName", objPackageImages.PackageImageName);
_logger.addMessage.Add("PackageImageTitle", objPackageImages.PackageImageTitle);
objparamlist.Add("PackageImageTitle", objPackageImages.PackageImageTitle);
IConnector objConnector = new Connector();
bool status = objConnector.ExecuteNonQuery("PackageModule", "InsertPackageImages", objparamlist);
_logger.addMessage.Add("AddPackageImages", "Package Images Saved Successfully");
}
catch (Exception ex)
{
AsyncLogger.LogEventVwr("UpdatePackageHotelCosting", ex.ToString(), ex.StackTrace);
_logger.addMessage.Add("AddPackageImages", "Error during Add Package Images Method Execution:" + ex.ToString());
}
finally
{
AsyncLogger.LogMessage(_logger);
}
}
public async Task ThreeClientsTwoLobbysTest()
{
var lg = new AsyncLogger();
var server = new Server();
server.Start(stdPort);
var player1 = new Player(PlayerType.PLAYER);
var player2 = new Player(PlayerType.PLAYER);
var player3 = new Player(PlayerType.PLAYER);
var game1 = new GameController(player1);
var game2 = new GameController(player2);
var game3 = new GameController(player3);
game1.StartOnline();
game2.StartOnline();
game3.StartOnline();
game1.Client.ClientSender.CreateLobby("111", true);
game2.Client.ClientSender.CreateLobby("222", true);
game3.Client.ClientSender.JoinLobby("111");
//Assert.Null(await Record.ExceptionAsync(() => lg.WaitForLobbys(server, 1)));
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForClientsInLobbys(server, new Dictionary <int, int> {
{ 0, 2 }, { 1, 1 }
})));
Assert.Equal("111", server.Lobbys[0].Password);
Assert.Equal("222", server.Lobbys[1].Password);
server.Stop();
}
public InsightOpsSink(InsightOpsSinkSettings config,
IFormatProvider formatProvider = null)
{
if (config is null)
{
throw new ArgumentNullException(nameof(config));
}
_formatProvider = formatProvider; // Optional.
ValidateToken(config.Token);
_asyncLogger = new AsyncLogger();
_asyncLogger.setToken(config.Token);
_asyncLogger.setRegion(config.Region);
_asyncLogger.setUseSsl(config.UseSsl);
// These options are more or less, not used.
_asyncLogger.setDebug(config.Debug);
_asyncLogger.setIsUsingDataHub(config.IsUsingDataHub);
_asyncLogger.setDataHubAddr(config.DataHubAddress);
_asyncLogger.setDataHubPort(config.DataHubPort);
_asyncLogger.setUseHostName(config.LogHostname);
_asyncLogger.setHostName(config.HostName);
_asyncLogger.setLogID(config.LogID);
}
public async Task StopWithoutFlush_Rejects_NotSavedLogs(int logsCount)
{
// arrange
var logsPath = Path.Combine(Path.GetTempPath(), $"IntegrationTests-{Guid.NewGuid()}");
using (var cut = new AsyncLogger(new List <ILogWriter> {
new ToFileWriter(logsPath, "testLog")
},
new LoggerDateProvider()))
{
var logTasks = Enumerable.Range(1, logsCount)
.Select(i => Task.Run(() => { cut.Write($"LogMessage number {i}"); }));
await Task.WhenAll(logTasks);
// act
cut.StopWithoutFlush();
}
await Task.Delay(100);
// assert (Two things can happen - file did not make it to emerge yet or it did but without writing all logs.
if (File.Exists(Path.Combine(logsPath, $"testLog_{DateTime.Today:yyyyMMdd}.log")))
{
Assert.NotEqual(logsCount, File.ReadAllLines(Directory.GetFiles(logsPath)[0]).Length);
}
Directory.Delete(logsPath, true);
}
public void DoesOutperformDefaultUnityLogQueueing(UnityEngine.LogType unityLogType, string message, int itterations)
{
// Arrange
var coreLogType = LogTypeMappings[unityLogType];
var stopWatch = Stopwatch.StartNew();
for (var i = 0; i < itterations; i++)
{
UnityEngine.Debug.unityLogger.Log(unityLogType, message);
}
stopWatch.Stop();
var defaultDuration = stopWatch.ElapsedMilliseconds;
long threadedDuration;
using (var threadedLogger = new AsyncLogger())
{
// Act
stopWatch.Restart();
for (var i = 0; i < itterations; i++)
{
threadedLogger.Log(coreLogType, message);
}
stopWatch.Stop();
threadedDuration = stopWatch.ElapsedMilliseconds;
}
// Assert
Assert.Less(threadedDuration, defaultDuration);
UnityEngine.Debug.Log($"Threaded: {threadedDuration}, Default: {defaultDuration}.");
}
public void DoesLogInOrder(int count)
{
// Arrange
var writer = new LogQueueWriter();
var formatter = new MessageOnlyFormatter();
using (var logger = new AsyncLogger(writer, formatter))
{
// Act
for (var i = 0; i < count; i++)
{
logger.Info(i.ToString());
}
while (!writer.Lines.Any())
{
}
logger.Flush();
}
// Assert
Assert.Equal(count, writer.Lines.Count);
var logLines = writer.Lines.Select(int.Parse).ToList();
for (var i = 0; i < logLines.Count - 1; i++)
{
Assert.Equal(logLines[i], logLines[i + 1] - 1);
}
}
public async Task AsyncLogger_UsesSameLogFile_JustBeforeMidnight()
{
// arrange
var logsPath = Path.Combine(Path.GetTempPath(), $"IntegrationTests-{Guid.NewGuid()}");
using (var beforeMidnightCut = new AsyncLogger(new List <ILogWriter> {
new ToFileWriter(logsPath, "testLog")
},
new LoggerDateProvider()))
{
beforeMidnightCut.Write("BeforeMidnight");
await beforeMidnightCut.StopWithFlush();
}
var loggerDate = Mock.Of <ILoggerDateProvider>(m => m.Now == DateTime.Now.Date.AddSeconds(-1).AddDays(1).Date);
using (var afterMidnightCut =
new AsyncLogger(new List <ILogWriter> {
new ToFileWriter(logsPath, "testLog")
}, loggerDate))
{
// act
afterMidnightCut.Write("AfterMidnight");
await afterMidnightCut.StopWithFlush();
}
await Task.Delay(100);
// assert
Assert.Single(Directory.GetFiles(logsPath));
Directory.Delete(logsPath, true);
}
public async Task StopWithoutFlush_When_Logs_Are_AlreadySaved_SimplyDoesNothing(int logsCount)
{
// arrange
var logsPath = Path.Combine(Path.GetTempPath(), $"IntegrationTests-{Guid.NewGuid()}");
using (var cut = new AsyncLogger(new List <ILogWriter> {
new ToFileWriter(logsPath, "testLog")
},
new LoggerDateProvider()))
{
var logTasks = Enumerable.Range(1, logsCount)
.Select(i => Task.Run(() => { cut.Write($"LogMessage number {i}"); }));
await Task.WhenAll(logTasks);
await Task.Delay(2000); // Give some time so we are sure all logs will be written;
// act
cut.StopWithoutFlush();
}
await Task.Delay(100);
// assert
Assert.Equal(logsCount, File.ReadAllLines(Directory.GetFiles(logsPath)[0]).Length);
Directory.Delete(logsPath, true);
}
public async Task ConnectTwoPlayersTest()
{
var lg = new AsyncLogger();
var server = new Server();
server.Start(stdPort);
var player1 = new Player(PlayerType.PLAYER);
var player2 = new Player(PlayerType.PLAYER);
var game1 = new GameController(player1);
var game2 = new GameController(player2);
game1.StartOnline();
game2.StartOnline();
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForConnectionsServer(server, 2)));
var player1Copy = server.Clients[0].Player;
var player2Copy = server.Clients[1].Player;
var e1 = player1.Name;
var e2 = player2.Name;
var a1 = server.Clients[0].Player.Name;
var a2 = server.Clients[1].Player.Name;
Assert.Equal(e1, a1);
Assert.Equal(e2, a2);
server.Stop();
}
public FileAccessLogger(uint redmineID)
{
logFilePath_ = Path.GetFullPath(Path.GetTempFileName());
fflCreate = new AsyncLogger(new FileLogger(logFilePath_));
fileLogSender_ = new FileAccessLogSender(logFilePath_);
WriteLine("RedmineID={0}", redmineID);
}
public void DoesFormat(LogType logType, string message)
{
// Arrange
var writer = new LogQueueWriter();
var formatter = new TypeMessageFormatter();
using (var logger = new AsyncLogger(writer, formatter))
{
// Act
logger.Log(logType, message);
while (!writer.Lines.Any())
{
}
logger.Flush();
}
// Assert
var originalLog = writer.Lines.Single();
var duplicateEntry = new LogEntry
{
LogType = logType,
Message = message
};
var duplicateLog = formatter.Format(duplicateEntry);
Assert.Equal(originalLog, duplicateLog);
}
public void InsertPackageCancellationPolicy(PackageDetails objPackageCancellationPolicy)
{
try
{
_logger.addMessage.Add("InsertPackageCancellationPolicy", "InsertPackageCancellationPolicy Method is going to Execute");
Dictionary <string, object> objparamlist = new Dictionary <string, object>();
_logger.addMessage.Add("CompanyID", objPackageCancellationPolicy.CompanyID);
objparamlist.Add("CompanyID", objPackageCancellationPolicy.CompanyID);
_logger.addMessage.Add("PackageCode", objPackageCancellationPolicy.BasicPackageDetails.PackageCode.ToString());
objparamlist.Add("PackageCode", objPackageCancellationPolicy.BasicPackageDetails.PackageCode);
_logger.addMessage.Add("PackageViewFormat", objPackageCancellationPolicy.PackageCancellationPolicy.ViewFormat.ToString());
objparamlist.Add("ViewFormat", objPackageCancellationPolicy.PackageCancellationPolicy.ViewFormat);
_logger.addMessage.Add("CancellationPolicyText", objPackageCancellationPolicy.PackageCancellationPolicy.CancellationPolicyText.ToString());
objparamlist.Add("CancellationPolicyText", objPackageCancellationPolicy.PackageCancellationPolicy.CancellationPolicyText);
IConnector objConnector = new Connector();
bool status = objConnector.ExecuteNonQuery("PackageModule", "FSP_InsertCancellationPolicy", objparamlist);
_logger.addMessage.Add("InsertPackageCancellationPolicy", "Cancellation policy inserted or updated successfully");
}
catch (Exception ex)
{
_logger.addMessage.Add("InsertPackageCancellationPolicy", "Error during Insert Package Cancellation Policy Method Execution:" + ex.ToString());
}
finally
{
AsyncLogger.LogMessage(_logger);
}
}
public async Task SlapOnlineTest()
{
var rnd = new Random();
var lg = new AsyncLogger();
var server = new Server();
server.Start(stdPort);
var player1 = new Player(PlayerType.PLAYER);
var player2 = new Player(PlayerType.PLAYER);
var game1 = new GameController(player1);
var game2 = new GameController(player2);
game1.StartOnline();
game2.StartOnline();
game1.Client.ClientSender.CreateLobby(stdPwd, true);
game2.Client.ClientSender.JoinLobby(stdPwd);
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForLobbys(server, 1)));
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForClientsInLobbys(server, new Dictionary <int, int> {
{ 0, 2 }
})));
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForClientValues(server)));
var attacker = game2.Players[0].Units[0];
var defender = game1.Players[0].Units[0];
game2.CombatController.CombatCalcRedirect(attacker, defender, attacker.Abilities[0]);
}
public async Task <ActionResult> AddArticleSale([FromBody] Article article)
{
AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(AddArticleSale)}. Input: {article}");
await _dataStore.AddSoldArticle(article);
return(Ok());
}
public async Task AsyncLogger_AfterDispose_CannotCall_StopWithFlush()
{
var logsPath = Path.Combine(Path.GetTempPath(), $"IntegrationTests-{Guid.NewGuid()}");
var cut = new AsyncLogger(new[] { new ToFileWriter(logsPath, "testLog") }, new LoggerDateProvider());
cut.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await cut.StopWithFlush());
}
public void AsyncLogger_AfterDispose_Cannot_WriteLogs()
{
var logsPath = Path.Combine(Path.GetTempPath(), $"IntegrationTests-{Guid.NewGuid()}");
var cut = new AsyncLogger(new[] { new ToFileWriter(logsPath, "testLog") }, new LoggerDateProvider());
cut.Dispose();
Assert.Throws <ObjectDisposedException>(() => cut.Write("I like kittens"));
}
/// <summary>
/// Get Hotel Saved Costing info for package pecific
/// </summary>
/// <param name="objHotelCosting"></param>
/// <returns></returns>
public List <HotelCosting> GetPackageHotelCosting(HotelCostingRequest objHotelCostingRequest)
{
List <HotelCosting> objlstHotelCosting = null;
try
{
_logger.addMessage.Add("UpdatePackageHotelCosting", "Package Hotel costing updated successfully");
Dictionary <string, object> objparamlist = new Dictionary <string, object>();
_logger.addMessage.Add("CompanyID", objHotelCostingRequest.CompanyID);
objparamlist.Add("CompanyID", objHotelCostingRequest.CompanyID);
_logger.addMessage.Add("PackageCode", objHotelCostingRequest.PackageCode);
objparamlist.Add("PackageCode", objHotelCostingRequest.PackageCode);
_logger.addMessage.Add("PackageLanguage", objHotelCostingRequest.PackageLanguage);
objparamlist.Add("PackageLanguage", objHotelCostingRequest.PackageLanguage);
IConnector objConnector = new Connector();
DataTable dtPackageHotelCosting = objConnector.ExecuteDataTable("PackageModule", "FSP_GetPkgHotelCosting", objparamlist);
_logger.addMessage.Add("GetHotelCosting", "Package costing fetch Successfully");
if (dtPackageHotelCosting.Rows.Count > 0)
{
objlstHotelCosting = new List <HotelCosting>();
for (int i = 0; i < dtPackageHotelCosting.Rows.Count; i++)
{
HotelCosting objHotelCosting = new HotelCosting();
objHotelCosting.CompanyID = objHotelCostingRequest.CompanyID;
objHotelCosting.PackageCode = objHotelCostingRequest.PackageCode;
objHotelCosting.Currency = dtPackageHotelCosting.Rows[i]["Currency"].ToString();
objHotelCosting.AdultCost = Convert.ToDouble(dtPackageHotelCosting.Rows[i]["AdultCost"]);
objHotelCosting.ChildCost = Convert.ToDouble(dtPackageHotelCosting.Rows[i]["ChildCost"]);
objHotelCosting.HotelCityName = dtPackageHotelCosting.Rows[i]["HotelCityName"].ToString();
objHotelCosting.HotelName = dtPackageHotelCosting.Rows[i]["HotelName"].ToString();
objHotelCosting.RoomType = dtPackageHotelCosting.Rows[i]["RoomType"].ToString();
objHotelCosting.PackageLanguage = dtPackageHotelCosting.Rows[i]["PackageLanguage"].ToString();
objHotelCosting.id = Convert.ToInt16(dtPackageHotelCosting.Rows[i]["id"]);
objlstHotelCosting.Add(item: objHotelCosting);
}
_logger.addMessage.Add("GetHotelCosting", "GetHotelCosting Method result" + JsonConvert.SerializeObject(objlstHotelCosting));
}
else
{
_logger.addMessage.Add("GetHotelCosting", "No Package Hotel Costing find for Package Code=" + objHotelCostingRequest.PackageCode);
}
}
catch (Exception ex)
{
AsyncLogger.LogEventVwr("UpdatePackageHotelCosting", ex.ToString(), ex.StackTrace);
_logger.ExceptionError = true;
_logger.addMessage.Add("GetHotelCosting", "Error during get Package hotel costing Method Execution:" + ex.ToString());
}
finally
{
AsyncLogger.LogMessage(_logger);
}
return(objlstHotelCosting);
}
public async Task MultipleServerTest_Fail()
{
var lg = new AsyncLogger();
var t1 = Task.Run(() => new Server().Start(44444));
var t2 = Task.Run(() => new Server().Start(44444));
Assert.NotNull(await Record.ExceptionAsync(() => lg.WaitForAsyncExceptions(3000)));
}
protected void Application_Start()
{
FileLog.Initialize("OMInsurance");
AsyncLogger.Initialize("OMInsurance");
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
ModelMapper.Configure();
}
public LogentriesTarget()
{
logentriesAsync = new AsyncLogger()
{
LogInternalDebug = InternalLogger.Debug,
LogInternalInfo = InternalLogger.Info,
LogInternalWarn = InternalLogger.Warn,
LogInternalError = InternalLogger.Error
};
}
protected void Application_Start()
{
FileLog.Initialize("RegApplPortal");
AsyncLogger.Initialize("RegApplPortal");
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AutoMapperConfig.RegisterMappings();
//ModelMapper.Configure();
}
public async Task StartServerTest()
{
var lg = new AsyncLogger();
var server = new Server();
server.Start(00000);
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForAsyncExceptions()));
server.Stop();
}
public async Task AsyncLogger_Silently_Swallows_Exception_AndConitnous_When_LogWriterThrowsException()
{
// arrange
var logWriterMock = new Mock <ILogWriter>();
logWriterMock.Setup(mock => mock.WriteLog(It.IsAny <LogLine>())).Throws(new Exception("I am a random Error! Say Hi :)"));
var cut = new AsyncLogger(new[] { logWriterMock.Object }, new LoggerDateProvider());
// act & assert
cut.Write("Nothing happens...");
await cut.StopWithFlush();
}
// TODO: How to clear the cache after a time? Can't hold on to this forever.
// TODO Do not store messages at all if features is disabled.
public MessageCache(DiscordSocketClient client, AsyncLogger logger, Func <ulong, GuildState> getConfFunc)
{
_dClient = client;
_outLog = logger;
_outGetConfig = getConfFunc;
CreateCacheTables();
client.MessageReceived += Client_MessageReceived;
client.MessageUpdated += Client_MessageUpdated;
client.MessageDeleted += Client_MessageDeleted;
}
/*private void SetServerUrl(HttpContext context = null)
* {
* if (!_IsInitialised)
* {
* lock (_initLocker)
* {
* //Not redunant - this check is more efficient for a 1-time set.
* //If it's set, we exit without locking. We want to avoid locking as much as possible, so only do it once (at startup)
* if (!_IsInitialised)
* {
* //First, try to read from the config
* var config = ObjectFactory.GetInstance<IConfigRepository>();
* var serverProtocol = config.Get("ServerProtocol", String.Empty);
* var domainName = config.Get("ServerDomainName", String.Empty);
* var domainPort = config.Get<int?>("ServerPort", null);
*
* if (!String.IsNullOrWhiteSpace(domainName) && !String.IsNullOrWhiteSpace(serverProtocol) && domainPort.HasValue)
* {
* Fr8.Infrastructure.Utilities.Server.ServerUrl = String.Format("{0}{1}{2}/", serverProtocol, domainName,
* domainPort.Value == 80 ? String.Empty : (":" + domainPort.Value));
*
* Fr8.Infrastructure.Utilities.Server.ServerHostName = domainName;
* }
* else
* {
* if (context == null)
* return;
*
* //If the config is not set, then we setup our server URL based on the first request
* string port = context.Request.ServerVariables["SERVER_PORT"];
* if (port == null || port == "80" || port == "443")
* port = "";
* else
* port = ":" + port;
*
* string protocol = context.Request.ServerVariables["SERVER_PORT_SECURE"];
* if (protocol == null || protocol == "0")
* protocol = "http://";
* else
* protocol = "https://";
*
* // *** Figure out the base Url which points at the application's root
* Fr8.Infrastructure.Utilities.Server.ServerHostName = context.Request.ServerVariables["SERVER_NAME"];
* string url = protocol + context.Request.ServerVariables["SERVER_NAME"] + port + context.Request.ApplicationPath;
* Fr8.Infrastructure.Utilities.Server.ServerUrl = url;
* }
* _IsInitialised = true;
* }
* }
* }
* }*/
public void Application_End()
{
//Logger.GetLogger().Info("fr8 web shutting down...");
Logger.GetLogger().Warn("fr8 web shutting down...");
// This will give LE background thread some time to finish sending messages to Logentries.
var numWaits = 3;
while (!AsyncLogger.AreAllQueuesEmpty(TimeSpan.FromSeconds(5)) && numWaits > 0)
{
numWaits--;
}
}
public async Task <ActionResult <DailyRevenue> > GetRevenue(DateTime targetDay)
{
AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(GetRevenue)}. Input: {targetDay:s}");
DailyRevenue result = (await _dataStore.GetRevenues(targetDay.Date, targetDay.Date)).SingleOrDefault();
if (result == null)
{
AsyncLogger.Log(LogLevel.Warning, $"{nameof(GetRevenue)} returned no values");
return(NoContent());
}
return(Ok(result));
}
public async Task <ActionResult <IEnumerable <DailyArticleRevenue> > > GetRevenueByArticle()
{
AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(GetRevenueByArticle)}");
IEnumerable <DailyArticleRevenue> result = await _dataStore.GetRevenuesByArticle(DateTime.MinValue, DateTime.Today);
if (!result.Any())
{
AsyncLogger.Log(LogLevel.Warning, $"{nameof(GetRevenueByArticle)} returned no values");
return(NoContent());
}
return(Ok(result));
}
public async Task Async_Log_SingleThread()
{
// Arrange
var logger = new AsyncLogger(_path);
var expected = true;
// Act
var actual = await logger.LogAsync(string.Format(_logMessage, "[Async]"));
// Assert
Assert.AreEqual(expected, actual);
Assert.IsTrue(File.Exists(_logFile));
}
public async Task MultipleServerTest_Pass()
{
var lg = new AsyncLogger();
var s1 = new Server();
var s2 = new Server();
var s3 = new Server();
s1.Start(11111);
s1.Start(22222);
s1.Start(33333);
Assert.Null(await Record.ExceptionAsync(() => lg.WaitForAsyncExceptions()));
}
