void Start(object newSocket)
{
try
{
var logStreamReader = LogReaderFactory.LogStreamReader(LogFormat);
logStreamReader.DefaultLogger = "TcpLogger";
using (var socket = (Socket)newSocket)
{
using (var ns = new NetworkStream(socket, FileAccess.Read, false))
{
int bytesRead;
do
{
foreach (var logMessage in logStreamReader.NextLogEvents(ns, out bytesRead))
{
logMessage.LoggerName = string.Format(":{1}.{0}", logMessage.LoggerName, Port);
OnNewMessage(logMessage);
}
} while (server != null && bytesRead > 0);
}
}
}
catch (IOException e)
{
Console.WriteLine(e);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Create a log reader based on the selected UI inputs
/// </summary>
/// <param name="query"></param>
/// <param name="output"></param>
/// <param name="logfile"></param>
/// <param name="machineName"></param>
/// <returns></returns>
public bool ReadLog(string query, Dictionary <string, Query> output, string logfile = "", string machineName = "")
{
LogReader lr;
if (LoadFromOption == LoadFromOptions.Live)
{
lr = LogReaderFactory.CreateLiveLogReader(query: query, server: machineName);
}
else
{
if (File.Exists(logfile))
{
lr = LogReaderFactory.CreateSavedLogReader(logfile, query);
}
else
{
MessageBoxResult result = MessageBox.Show("Invalid Log File", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
}
try {
lr.ReadLog(output, ct);
}
catch (Exception e) {
MessageBoxResult result = MessageBox.Show(e.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
return(true);
}
private void Start()
{
var logParser = LogReaderFactory.LogParser(LogFormat);
while (true)
{
try
{
byte[] buffer = _udpClient.Receive(ref _remoteEndPoint);
string loggingEvent = System.Text.Encoding.UTF8.GetString(buffer);
LogMessage logMsg = logParser.TryParseLogEvent(loggingEvent, "UdpLogger");
logMsg.LoggerName = string.Format("{0}_{1}", _remoteEndPoint.Address.ToString().Replace(".", "-"), logMsg.LoggerName);
OnNewMessage(logMsg);
}
catch (SocketException)
{
return;
}
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
}
private void StartWatch(object sender, RoutedEventArgs e)
{
//read textbox values
string machineName = MachineName.Text;
string logFile = LogFile.Text;
//create query
//4 = Information Log Level (required)
//11,12 - EventIDs of the start/end query processing (required)
string s = LogQueryBuilder.Build(
new List <int> {
4
},
new List <int> {
11, 12
}
);
//Create logreader -> sign up for new logreader events -> Begin watching
watchingLogReader = LogReaderFactory.CreateLiveLogReader(query: s, server: machineName);
watchingLogReader.CompleteQueryWrittenEvent += WriteWatchResults;
bool watchStartSuccessful = watchingLogReader.StartWatch();
if (watchStartSuccessful)
{
//update UI with available options
StartWatchButton.IsEnabled = false;
ParseButton.IsEnabled = false;
CancelButton.IsEnabled = true;
Processing.Content = "Processing";
dispatcherTimer.Start();
//set outputwriter to whatever output option was chosen in the ui
switch (SaveAsOption)
{
default:
case SaveAsOptions.EventFrame:
outputWriter = new AFWriter(db);
break;
case SaveAsOptions.Text:
outputWriter = new TextFileWriter(FileOutput.Text);
break;
case SaveAsOptions.Console:
outputWriter = new ConsoleWriter();
break;
}
}
else
{
MessageBoxResult result = MessageBox.Show("Error creating log watcher - this feature is not available with this version", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
static Logger()
{
var loggerFactory = new LoggerFactory();
LoggerInterface = loggerFactory.GetLoggerRepository();
var logReaderFactory = new LogReaderFactory();
LogReader = logReaderFactory.GetLogReaderRepository();
}
static Logger()
{
var loggerFactory = new LoggerFactory();
LoggerInterface = loggerFactory.GetLoggerRepository();
var logReaderFactory = new LogReaderFactory();
LogReader = logReaderFactory.GetLogReaderRepository();
LogReaderV2 = logReaderFactory.GetLogReaderV2Repository();
var transactionFactory = new TransactionFactory();
TransactionInterface = transactionFactory.GetTransactionRepository();
}
static void Main(string[] args)
{
string s = LogQueryBuilder.Build(
new List <int> {
4
},
new List <int> {
11, 12
},
DateTime.Now.AddDays(-1)
);
LogReader log = LogReaderFactory.CreateSavedLogReader(@"C:\WebAPILog\Analytic.evtx", s);
var result = new Dictionary <string, Query>();
log.ReadLog(result);
foreach (Query q in result.Values)
{
Console.WriteLine(q);
}
Console.WriteLine("<ENTER> to EXIT");
Console.ReadLine();
}
protected void GivenLogReader(string logFileName, long length, int maxStreams)
{
LogReaderFactory.Setup(x => x.Create(logFileName, It.IsInRange(0L, Math.Max(CurrentLogFilePosition, length), Range.Inclusive)))
.Returns((string fileName, long position) =>
{
var internalPosition = position > length ? length : position;
var streamsLeft = maxStreams;
var reader = _mockRepository.Create <ILogReader>();
reader.SetupGet(x => x.Position).Returns(() => internalPosition);
reader.Setup(x => x.ReadLine()).Returns(() =>
{
internalPosition++;
streamsLeft--;
if (internalPosition > length || streamsLeft < 0)
{
internalPosition = length;
return(new MemoryStream());
}
return(new MemoryStream(new byte[1]));
});
reader.Setup(x => x.Dispose()).Callback(() => { reader.Reset(); });
return(reader.Object);
});
}
protected void GivenLogReaderCreateIOError(string fileName, long position)
{
LogReaderFactory.Setup(x => x.Create(fileName, position)).Throws <IOException>();
}
private static MainWindowViewModel CreateMainWindowViewModel()
{
var logReaderFactory = new LogReaderFactory();
return(new MainWindowViewModel(logReaderFactory));
}
