public void LoggerUDP_Test()
{
int bufferLimit = 7, loggersCount = 10000;
string clientIP = "127.0.0.1";
int clientPort = 8000;
string serverIP = "127.0.0.1";
int serverPort = 8888;
Logger_UDP_Test server = new Logger_UDP_Test(serverIP, serverPort, loggersCount);
server.ReceiveMessages();
LoggerTarget_UDP loggerUDP = new LoggerTarget_UDP(clientIP, clientPort, serverIP, serverPort);
ILoggerTarget[] loggerTargets = new ILoggerTarget[] { loggerUDP };
Logger logger = new Logger(bufferLimit, loggerTargets);
for (int i = 0; i < loggersCount; i++)
{
logger.Log(new LoggerInformation(LogLevel.Info, "task" + (i + 1)));
}
logger.LoggerFlushControl();
server.Close();
Assert.AreEqual(Logger_UDP_Test.udp_count, 10000);
}
public static void AddLoggerTarget(ILoggerTarget target)
{
if (LoggerTargets.Contains(target))
return;
LoggerTargets.Add(target);
}
public void CheckFlushOrderByThreads()
{
ILoggerTarget[] loggerTarget = new ILoggerTarget[2];
loggerTarget[0] = fileTarget;
loggerTarget[1] = udpPortTarget;
Logger logger = new Logger(2, loggerTarget);
ListenerLogsFromUdpPort listener = new ListenerLogsFromUdpPort(port);
listener.StartListen();
LogThreadPool.RunAndWaitLogingThreads(10, 2, logger);
while (!logger.IsFlushLogThreadPoolClear)
{
;
}
LoggerWithFileTargetTest.TestMethod(targetFileName);
listener.StopListen();
while (listener.IsRunningListenerThread)
{
;
}
}
public static void DeregisterPresenter(ILoggerTarget logTargetView)
{
Log.ShowLog -= delegate(string obj)
{
logTargetView.SetCommandLine(obj);
};
}
public static bool Import(string fileName, ILoggerTarget<LoggedChat> target, int limitEndOfStreamImportToNumberOfBytes = 1048576)
{
List<ILoggerTarget<LoggedChat>> list = new List<ILoggerTarget<LoggedChat>>();
list.Add(target);
return Import(fileName, list, limitEndOfStreamImportToNumberOfBytes);
}
public static bool Import(string fileName, ILoggerTarget <LoggedChat> target, int limitEndOfStreamImportToNumberOfBytes = 1048576)
{
List <ILoggerTarget <LoggedChat> > list = new List <ILoggerTarget <LoggedChat> >();
list.Add(target);
return(Import(fileName, list, limitEndOfStreamImportToNumberOfBytes));
}
public static void RegisterTarget(ILoggerTarget target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target), "Logger target cannot be null");
}
Targets.Add(target);
}
static void Main(string[] args)
{
int bufferLimit = 5;
ILoggerTarget[] logTarget = new ILoggerTarget[] { new LoggerTargetFile("FileLog.txt"), new LoggerTargetUdp("127.0.0.1", 9000, "127.0.0.1", 10000) };
var controller = new LogsCreator(new Logger(bufferLimit, logTarget));
controller.CreateLogs(10000, LogLevel.Info);
Console.ReadKey();
}
public void CheckFlushOrderInFileTargetByThreads()
{
ILoggerTarget[] loggerTargets = new ILoggerTarget[1];
loggerTargets[0] = new FileTarget(targetFileName);
Logger logger = new Logger(2, loggerTargets);
LogThreadPool.RunAndWaitLogingThreads(50, 2, logger);
while (!logger.IsFlushLogThreadPoolClear)
{
;
}
TestMethod(targetFileName);
}
public void LoggerFile_Test()
{
int bufferLimit = 3, loggersCount = 10000;
LoggerTarget loggerFile = new LoggerTarget("E:\\Test_Logger_File.txt");
ILoggerTarget[] loggerTargets = new ILoggerTarget[] { loggerFile };
Logger logger = new Logger(bufferLimit, loggerTargets);
for (int i = 0; i < loggersCount; i++)
{
logger.Log(new LoggerInformation(LogLevel.Info, "task" + (i + 1) + " start"));
}
logger.LoggerFlushControl();
loggerFile.CloseFile();
}
public void TestMethod_TestOneTarget()
{
int bufferLimit = 1, logsCount = 10000;
TestTarget testTarget = new TestTarget();
StringBuilder stringBuilder = new StringBuilder();
ILoggerTarget[] logTarget = new ILoggerTarget[] { testTarget };
var controller = new LogsCreator(new Logger(bufferLimit, logTarget));
controller.CreateLogs(logsCount, LogLevel.Info);
for (int i = 0; i < logsCount; i++)
{
stringBuilder.Append(i);
}
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), testTarget.GetMessage());
testTarget.Close();
}
public void TestMethod_TestUdpTarget()
{
index = 0;
byte bufferLimit = 5;
int logsCount = 100;
TestUdpServer udpServer = new TestUdpServer("127.0.0.1", 9000);
LoggerTargetUdp targetUdp = new LoggerTargetUdp("127.0.0.1", 9000, "127.0.0.1", 10000);
StringBuilder stringBuilder = new StringBuilder();
ILoggerTarget[] logTarget = new ILoggerTarget[] { targetUdp };
udpServer.StartReceive();
Logger logger = new Logger(bufferLimit, logTarget);
Task.Run(() =>
{
logger.ProcessingQueue();
});
for (int i = 0; i < logsCount; i++)
{
string a = "task " + i;
Task.Run(() =>
{
logger.Log(LogLevel.Info, a);
index++;
});
}
while (index != logsCount)
{
if (index == logsCount)
{
logger.FlushReamainLogs();
for (int i = 0; i < logsCount; i++)
{
stringBuilder.Append(i);
}
udpServer.Synchronize();
udpServer.Close();
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), udpServer.GetMessage());
}
}
}
public void TestMethod_TestTwoTargets()
{
index = 0;
byte bufferLimit = 1;
int logsCount = 10;
TestTarget firstTestTarget = new TestTarget();
TestTarget secondTestTarget = new TestTarget();
StringBuilder stringBuilder = new StringBuilder();
ILoggerTarget[] logTarget = new ILoggerTarget[] { firstTestTarget, secondTestTarget };
Logger logger = new Logger(bufferLimit, logTarget);
Task.Run(() =>
{
logger.ProcessingQueue();
});
for (int i = 0; i < logsCount; i++)
{
string a = "task " + i;
Task.Run(() =>
{
logger.Log(LogLevel.Info, a);
index++;
});
}
while (index != logsCount)
{
if (index == logsCount)
{
logger.FlushReamainLogs();
for (int i = 0; i < logsCount; i++)
{
stringBuilder.Append(i);
}
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), firstTestTarget.GetMessage());
firstTestTarget.Close();
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), secondTestTarget.GetMessage());
secondTestTarget.Close();
}
}
}
public void LoggerUDP_Test()
{
int bufferLimit = 3, loggersCount = 10000;
string clientIP = "127.0.0.1";
int clientPort = 8000;
string serverIP = "127.0.0.1";
int serverPort = 8888;
LoggerTarget_UDP loggerUDP = new LoggerTarget_UDP(clientIP, clientPort, serverIP, serverPort);
ILoggerTarget[] loggerTargets = new ILoggerTarget[] { loggerUDP };
Logger logger = new Logger(bufferLimit, loggerTargets);
for (int i = 0; i < loggersCount; i++)
{
logger.Log(new LoggerInformation(LogLevel.Info, "task" + (i + 1) + " start"));
}
logger.LoggerFlushControl();
loggerUDP.Close();
}
public void TestMethod_TestTwoTargets()
{
int bufferLimit = 5, logsCount = 10000;
TestTarget firstTestTarget = new TestTarget();
TestTarget secondTestTarget = new TestTarget();
StringBuilder stringBuilder = new StringBuilder();
ILoggerTarget[] logTarget = new ILoggerTarget[] { firstTestTarget, secondTestTarget };
var logsCreator = new LogsCreator(new Logger(bufferLimit, logTarget));
logsCreator.CreateLogs(logsCount, LogLevel.Debug);
for (int i = 0; i < logsCount; i++)
{
stringBuilder.Append(i);
}
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), firstTestTarget.GetMessage());
firstTestTarget.Close();
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), secondTestTarget.GetMessage());
secondTestTarget.Close();
}
public void TestMethod_TestUdpTarget()
{
int bufferLimit = 5, logsCount = 100;
TestUdpServer udpServer = new TestUdpServer("127.0.0.1", 9000);
LoggerTargetUdp targetUdp = new LoggerTargetUdp("127.0.0.1", 9000, "127.0.0.1", 10000);
StringBuilder stringBuilder = new StringBuilder();
ILoggerTarget[] logTarget = new ILoggerTarget[] { targetUdp };
udpServer.StartReceive();
var logsCreator = new LogsCreator(new Logger(bufferLimit, logTarget));
logsCreator.CreateLogs(logsCount, LogLevel.Debug);
for (int i = 0; i < logsCount; i++)
{
stringBuilder.Append(i);
}
udpServer.Synchronize();
udpServer.Close();
CollectionAssert.AreEqual(Encoding.Default.GetBytes(stringBuilder.ToString()), udpServer.GetMessage());
}
private static void Main(string[] args)
{
Console.Write("Input limit of buffer:");
byte limit = Convert.ToByte(Console.ReadLine());
Console.Write("Input count logs:");
int countLogs = Convert.ToInt32(Console.ReadLine());
FileStream fileStream = new FileStream(@"C:\My Documents\GitHub\MPP-LAB3--Concurrent-logger\Concurrent logger\Concurrent logger\output.txt", FileMode.OpenOrCreate);
LoggerTarget loggetTarget = new LoggerTarget(fileStream);
ILoggerTarget[] iLoggerTarget = new ILoggerTarget[] { loggetTarget };
Logger logger = new Logger(limit, iLoggerTarget);
Task.Run(() =>
{
logger.ProcessingQueue();
});
for (int i = 0; i < countLogs; i++)
{
string a = "task " + i;
Task.Run(() =>
{
logger.Log(LogLevel.Info, a);
index++;
});
}
while (index != countLogs)
{
if (index == countLogs)
{
logger.FlushReamainLogs();
fileStream.Close();
fileStream.Dispose();
Console.ReadKey();
}
}
}
static void Main(string[] args)
{
LoggerTarget loggerFile = new LoggerTarget("E:\\LoggerFile.txt");
ILoggerTarget[] loggerTargets = new ILoggerTarget[] { loggerFile };
Console.WriteLine("Введите максимальное количество объектов в буфере: ");
int bufferLimit = Convert.ToInt32(Console.ReadLine());
Logger logger = new Logger(bufferLimit, loggerTargets);
for (int i = 0; i < 100000; i++)
{
logger.Log(new LoggerInformation(LogLevel.Info, "task" + (i + 1) + " start"));
}
logger.LoggerFlushControl();
loggerFile.CloseFile();
Console.WriteLine("-----------------");
Console.WriteLine("Работа завершена!");
}
public void CheckFlushOrderInUdpPortTargetByThreads()
{
ILoggerTarget[] loggerTargets = new ILoggerTarget[1];
loggerTargets[0] = udpPortTarget;
Logger logger = new Logger(2, loggerTargets);
ListenerLogsFromUdpPort listener = new ListenerLogsFromUdpPort(port);
listener.StartListen();
LogThreadPool.RunAndWaitLogingThreads(10, 2, logger);
while (!logger.IsFlushLogThreadPoolClear)
{
;
}
listener.StopListen();
while (listener.IsRunningListenerThread)
{
;
}
}
public void LoggerFile_Test()
{
int bufferLimit = 3, loggersCount = 1000;
int count = 0, i = 0;
string[] allMessages = new string[1000];
LoggerTarget loggerFile = new LoggerTarget("E:\\Test_Logger_File.txt");
ILoggerTarget[] loggerTargets = new ILoggerTarget[] { loggerFile };
Logger logger = new Logger(bufferLimit, loggerTargets);
for (i = 0; i < loggersCount; i++)
{
logger.Log(new LoggerInformation(LogLevel.Info, "task" + (i + 1)));
}
for (i = 0; i < loggersCount; i++)
{
allMessages[i] = LogLevel.Info + " task" + (i + 1);
}
logger.LoggerFlushControl();
loggerFile.CloseFile();
string[] fileText = File.ReadAllLines("E:\\Test_Logger_File.txt");
i = 0;
foreach (string line in fileText)
{
if (line.EndsWith(allMessages[i]))
{
count++;
}
i++;
}
Assert.AreEqual(count, 1000);
}
public static void Trace(this ILoggerTarget log, string message) => log.Log(message, LogLevel.Trace);
private async Task FlushAsync(ILoggerTarget loggerTarget, LogInfo[] logsInfo)
{
bool result = await loggerTarget.FlushAsync(logsInfo);
}
public void AddTarget(ILoggerTarget target)
{
targets.Add(target);
}
public static void RegisterLoggerTarget(ILoggerTarget target)
{
_instance._targets.Add(target);
}
public static void Error(this ILoggerTarget log, string message) => log.Log(message, LogLevel.Error);
public static void Warn(this ILoggerTarget log, string message) => log.Log(message, LogLevel.Warn);
public static void Debug(this ILoggerTarget log, string message) => log.Log(message, LogLevel.Debug);
public ILogger WithTarget(ILoggerTarget target)
{
_loggerTargets.Add(target);
return(this);
}
public static void Info(this ILoggerTarget log, string message) => log.Log(message, LogLevel.Info);
