protected override void WriteTestScenario()
{
_prepare1 = WriteSingleEvent("ES", 0, "test1");
_prepare2 = WriteSingleEvent("ESES", 0, "test2");
_prepare3 = WriteSingleEvent("ESES", 1, "test3");
}
public ResolvedEvent(EventRecord @event, long commitPosition)
{
Event = @event;
Link = null;
OriginalPosition = new TFPos(commitPosition, @event.LogPosition);
ResolveResult = default(ReadEventResult);
}
public ResolvedEvent(EventRecord @event)
{
Event = @event;
Link = null;
OriginalPosition = null;
ResolveResult = default(ReadEventResult);
}
protected override void WriteTestScenario()
{
var now = DateTime.UtcNow;
var metadata1 = string.Format(@"{{""$maxAge"":{0}}}", (int)TimeSpan.FromMinutes(25).TotalSeconds);
const string metadata2 = @"{""$maxCount"":2}";
_r11 = WriteStreamMetadata("ES1", 0, metadata1);
_r21 = WriteStreamMetadata("ES2", 0, metadata2);
_r12 = WriteSingleEvent("ES1", 0, "bla1", now.AddMinutes(-100));
_r13 = WriteSingleEvent("ES1", 1, "bla1", now.AddMinutes(-20));
_r22 = WriteSingleEvent("ES2", 0, "bla1", now.AddMinutes(-100));
_r23 = WriteSingleEvent("ES2", 1, "bla1", now.AddMinutes(-20));
_r14 = WriteSingleEvent("ES1", 2, "bla1", now.AddMinutes(-11));
_r24 = WriteSingleEvent("ES2", 2, "bla1", now.AddMinutes(-10));
_r15 = WriteSingleEvent("ES1", 3, "bla1", now.AddMinutes(-5));
_r16 = WriteSingleEvent("ES1", 4, "bla1", now.AddMinutes(-2));
_r25 = WriteSingleEvent("ES2", 3, "bla1", now.AddMinutes(-1));
_r26 = WriteSingleEvent("ES2", 4, "bla1", now.AddMinutes(-1));
}
public static EntryElement ToEntry(EventRecord evnt, string userHostName)
{
if (evnt == null || userHostName == null)
return null;
var entry = new EntryElement();
entry.SetTitle(String.Format("{0} #{1}", evnt.EventStreamId, evnt.EventNumber));
entry.SetId(HostName.Combine(userHostName, "/streams/{0}/{1}", evnt.EventStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(String.Format("Entry #{0}", evnt.EventNumber));
entry.AddLink(HostName.Combine(userHostName, "/streams/{0}/{1}", evnt.EventStreamId, evnt.EventNumber), "edit", null);
entry.AddLink(
HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=text", evnt.EventStreamId, evnt.EventNumber),
null,
ContentType.PlainText);
entry.AddLink(
HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=json", evnt.EventStreamId, evnt.EventNumber),
"alternate",
ContentType.Json);
entry.AddLink(
HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=xml", evnt.EventStreamId, evnt.EventNumber),
"alternate",
ContentType.Xml);
return entry;
}
protected override void WriteTestScenario()
{
var t1 = WriteTransactionBegin("ES", ExpectedVersion.NoStream);
var t2 = WriteTransactionBegin("ABC", ExpectedVersion.NoStream);
_p1 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 0, t1.EventStreamId, 0, "es1", PrepareFlags.Data);
_p2 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 0, t2.EventStreamId, 0, "abc1", PrepareFlags.Data);
_p3 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 1, t1.EventStreamId, 1, "es1", PrepareFlags.Data);
_p4 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 1, t2.EventStreamId, 1, "abc1", PrepareFlags.Data);
_p5 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 2, t1.EventStreamId, 2, "es1", PrepareFlags.Data);
WriteTransactionEnd(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId);
WriteTransactionEnd(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId);
_t2CommitPos = WriteCommit(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId, _p2.EventNumber);
_t1CommitPos = WriteCommit(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId, _p1.EventNumber);
_pos6 = Db.Config.WriterCheckpoint.ReadNonFlushed();
var r6 = LogRecord.Prepare(_pos6, Guid.NewGuid(), Guid.NewGuid(), _pos6, 0, "t1", -1, PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
Writer.Write(r6, out _pos7);
var r7 = LogRecord.Prepare(_pos7, Guid.NewGuid(), Guid.NewGuid(), _pos7, 0, "t1", -1, PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
Writer.Write(r7, out _pos8);
var r8 = LogRecord.Prepare(_pos8, Guid.NewGuid(), Guid.NewGuid(), _pos8, 0, "t1", -1, PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
long pos9;
Writer.Write(r8, out pos9);
}
protected override void WriteTestScenario()
{
_event1 = WriteSingleEvent("account--696193173", 0, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("account--696193173", 0, new string('.', 3000), retryOnFail: true);
_event2 = WriteSingleEvent("LPN-FC002_LPK51001", 0, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("LPN-FC002_LPK51001", 0, new string('.', 3000), retryOnFail: true);
_event3 = WriteSingleEvent("account--696193173", 1, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("account--696193173", 1, new string('.', 3000), retryOnFail: true);
_event4 = WriteSingleEvent("LPN-FC002_LPK51001", 1, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("LPN-FC002_LPK51001", 1, new string('.', 3000), retryOnFail: true);
_event5 = WriteSingleEvent("account--696193173", 2, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("account--696193173", 2, new string('.', 3000), retryOnFail: true);
_event6 = WriteSingleEvent("LPN-FC002_LPK51001", 2, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("LPN-FC002_LPK51001", 2, new string('.', 3000), retryOnFail: true);
_event7 = WriteSingleEvent("account--696193173", 3, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("account--696193173", 3, new string('.', 3000), retryOnFail: true);
_event8 = WriteSingleEvent("LPN-FC002_LPK51001", 3, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("LPN-FC002_LPK51001", 3, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("RandomStream", 0, new string('.', 3000), retryOnFail: true);
WriteSingleEvent("RandomStream", 1, new string('.', 3000), retryOnFail: true);
Scavenge(completeLast: false, mergeChunks: false);
}
protected override void WriteTestScenario()
{
_prepare1 = WriteSingleEvent("AB", 0, "test1");
_delete1 = WriteDelete("AB");
_prepare2 = WriteSingleEvent("CD", 0, "test2");
}
public EventLinkPair(Data.EventRecord eventRecord, Data.EventRecord linkRecord)
{
Event = new EventRecord(eventRecord);
if (linkRecord != null)
Link = new EventRecord(linkRecord);
}
public IndexReadEventResult(ReadEventResult result, EventRecord record, StreamMetadata metadata, int lastEventNumber)
{
Result = result;
Record = record;
Metadata = metadata;
LastEventNumber = lastEventNumber;
}
public IndexReadEventResult(ReadEventResult result, EventRecord record, StreamMetadata metadata, int lastEventNumber, bool originalStreamExists)
{
Result = result;
Record = record;
Metadata = metadata;
LastEventNumber = lastEventNumber;
OriginalStreamExists = originalStreamExists;
}
protected override void WriteTestScenario()
{
_event1 = WriteSingleEvent("ES", 0, new string('.', 500));
_event2 = WriteSingleEvent("ES", 1, new string('.', 500)); // truncated
_event3 = WriteSingleEvent("ES", 2, new string('.', 500)); // truncated
TruncateCheckpoint = _event2.LogPosition;
}
public ReadEventResult(SingleReadResult result)
{
if (result == SingleReadResult.Success)
throw new ArgumentException(string.Format("Wrong SingleReadResult provided for failure constructor: {0}.", result), "result");
Result = result;
Record = null;
}
public ResolvedEvent(
EventRecord @event, EventRecord link, ReadEventResult resolveResult = default(ReadEventResult))
{
Event = @event;
Link = link;
OriginalPosition = null;
ResolveResult = resolveResult;
}
protected override void WriteTestScenario()
{
_p1 = WriteTransactionBegin("ES", ExpectedVersion.NoStream, 0, "test1");
_p2 = WriteTransactionEvent(_p1.CorrelationId, _p1.LogPosition, 1, _p1.EventStreamId, 1, "test2", PrepareFlags.Data);
_p3 = WriteTransactionEvent(_p1.CorrelationId, _p1.LogPosition, 2, _p1.EventStreamId, 2, "test3", PrepareFlags.TransactionEnd | PrepareFlags.Data);
WriteCommit(_p1.CorrelationId, _p1.LogPosition, _p1.EventStreamId, _p1.EventNumber);
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla");
_event1 = WriteSingleEvent("ES", 1, "bla");
_event2 = WriteSingleEvent("ES", 2, "bla");
_event3 = WriteSingleEvent("ES", 3, "bla");
_event4 = WriteSingleEvent("ES", 4, "bla");
}
protected override void WriteTestScenario()
{
_event0 = WriteStreamCreated("ES", @"{""$maxCount"":3}");
_event1 = WriteSingleEvent("ES", 1, "bla");
_event2 = WriteSingleEvent("ES", 2, "bla");
_event3 = WriteSingleEvent("ES", 3, "bla");
_event4 = WriteSingleEvent("ES", 4, "bla");
_event5 = WriteSingleEvent("ES", 5, "bla");
}
public ResolvedEvent(
EventRecord @event, EventRecord link, long commitPosition,
ReadEventResult resolveResult = default(ReadEventResult))
{
Event = @event;
Link = link;
OriginalPosition = new TFPos(commitPosition, (link ?? @event).LogPosition);
ResolveResult = resolveResult;
}
protected override void WriteTestScenario()
{
WriteStreamMetadata("ES", 0, @"{""$tb"":2}");
WriteSingleEvent("ES", 0, "bla");
WriteSingleEvent("ES", 1, "bla");
_event3 = WriteSingleEvent("ES", 2, "bla");
_event4 = WriteSingleEvent("ES", 3, "bla");
_event5 = WriteSingleEvent("ES", 4, "bla");
}
public IndexReadEventResult(ReadEventResult result, StreamMetadata metadata)
{
if (result == ReadEventResult.Success)
throw new ArgumentException(string.Format("Wrong ReadEventResult provided for failure constructor: {0}.", result), "result");
Result = result;
Record = null;
Metadata = metadata;
}
protected override void WriteTestScenario()
{
WriteSingleEvent("ES", 0, new string('.', 500));
_event2 = WriteSingleEvent("ES", 1, new string('.', 500));
WriteSingleEvent("ES", 2, new string('.', 500)); // index goes to disk
WriteSingleEvent("ES", 3, new string('.', 500));
TruncateCheckpoint = _event2.LogPosition;
}
public static FeedElement ToFeed(string eventStreamId,
int start,
int count,
DateTime updateTime,
EventRecord[] items,
Func<EventRecord, string, EntryElement> itemToEntry,
string userHostName)
{
if (string.IsNullOrEmpty(eventStreamId) || items == null || userHostName == null)
return null;
if (start == -1)
start = GetActualStart(items);
var self = HostName.Combine(userHostName, "/streams/{0}", eventStreamId);
var feed = new FeedElement();
feed.SetTitle(String.Format("Event stream '{0}'", eventStreamId));
feed.SetId(self);
feed.SetUpdated(updateTime);
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink(self, "self", null);
feed.AddLink(HostName.Combine(userHostName,
"/streams/{0}/range/{1}/{2}",
eventStreamId,
AtomSpecs.FeedPageSize - 1,
AtomSpecs.FeedPageSize),
"first",
null);
feed.AddLink(HostName.Combine(userHostName,
"/streams/{0}/range/{1}/{2}",
eventStreamId,
PrevStart(start),
AtomSpecs.FeedPageSize),
"prev",
null);
feed.AddLink(HostName.Combine(userHostName,
"/streams/{0}/range/{1}/{2}",
eventStreamId,
NextStart(start),
AtomSpecs.FeedPageSize),
"next",
null);
foreach (var item in items)
{
feed.AddEntry(itemToEntry(item, userHostName));
}
return feed;
}
public ReadStreamResult(RangeReadResult result, EventRecord[] records, int nextEventNumber, int lastEventNumber, bool isEndOfStream)
{
Ensure.NotNull(records, "records");
Result = result;
Records = records;
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
var prepare = LogRecord.DeleteTombstone(WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(), "ES", 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
var now = DateTime.UtcNow;
var metadata = string.Format(@"{{""$maxAge"":{0},""$maxCount"":3}}", (int)TimeSpan.FromMinutes(60).TotalSeconds);
_r1 = WriteStreamCreated("ES", metadata, now.AddMinutes(-100));
_r2 = WriteSingleEvent("ES", 1, "bla1", now.AddMinutes(-50));
_r3 = WriteSingleEvent("ES", 2, "bla1", now.AddMinutes(-20));
_r4 = WriteSingleEvent("ES", 3, "bla1", now.AddMinutes(-11));
_r5 = WriteSingleEvent("ES", 4, "bla1", now.AddMinutes(-5));
_r6 = WriteSingleEvent("ES", 5, "bla1", now.AddMinutes(-1));
}
public IndexReadEventResult(ReadEventResult result, StreamMetadata metadata, int lastEventNumber, bool originalStreamExists)
{
if (result == ReadEventResult.Success)
throw new ArgumentException(string.Format("Wrong ReadEventResult provided for failure constructor: {0}.", result), "result");
Result = result;
Record = null;
Metadata = metadata;
LastEventNumber = lastEventNumber;
OriginalStreamExists = originalStreamExists;
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
10,
new PrepareLogRecord(
500, Guid.NewGuid(), Guid.NewGuid(), 500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommited = new StorageMessage.EventCommited(1000, _eventRecord);
}
protected override void WriteTestScenario()
{
const string metadata = @"{""$maxCount"":4}";
_r1 = WriteStreamMetadata("ES", 0, metadata);
_r2 = WriteSingleEvent("ES", 0, "bla1");
_r3 = WriteSingleEvent("ES", 1, "bla1");
_r4 = WriteSingleEvent("ES", 2, "bla1");
_r5 = WriteSingleEvent("ES", 3, "bla1");
_r6 = WriteSingleEvent("ES", 4, "bla1");
}
protected override void WriteTestScenario()
{
var now = DateTime.UtcNow;
var metadata = string.Format(@"{{""$maxAge"":{0}}}", (int)TimeSpan.FromMinutes(20).TotalSeconds);
WriteStreamMetadata("ES", 0, metadata, now.AddMinutes(-100));
WriteSingleEvent("ES", 0, "bla", now.AddMinutes(-50));
WriteSingleEvent("ES", 1, "bla", now.AddMinutes(-25));
_event2 = WriteSingleEvent("ES", 2, "bla", now.AddMinutes(-15));
_event3 = WriteSingleEvent("ES", 3, "bla", now.AddMinutes(-11));
_event4 = WriteSingleEvent("ES", 4, "bla", now.AddMinutes(-3));
}
protected override void WriteTestScenario()
{
_event1 = WriteStreamCreated("ES");
_event2 = WriteSingleEvent("ES", 1, "bla1");
var prepare = LogRecord.DeleteTombstone(WriterChecksum.ReadNonFlushed(), Guid.NewGuid(), "ES", 2);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event3 = WriteSingleEvent("ES", 2, "bla1");
Scavenge();
}
static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Usage: GetEventLog activityId machines");
Console.WriteLine("Example: GetEventLog \"0724A8D0-D873-4CB3-8762-C9A70084DD98\" \"server1.company.com,server2.company.com\"");
return;
}
string activityId = args[0];
string machineNames = args[1];
string adfsAdminLogName = "AD FS 2.0/Admin";
string[] machineNamesArray = machineNames.Split(new char[1] {
','
});
foreach (string machineName in machineNamesArray)
{
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------------------------");
Console.WriteLine("Getting AD FS event logs with correlation activity ID " + activityId + " from " + machineName);
string query = "*[System/Correlation/@ActivityID=\"{" + activityId + "}\"]";
EventLogQuery eventLogQuery = new EventLogQuery(adfsAdminLogName, PathType.LogName, query);
eventLogQuery.Session = new EventLogSession(machineName);
EventLogReader eventLogReader = new EventLogReader(eventLogQuery);
for (EventRecord eventRecord = eventLogReader.ReadEvent(); eventRecord != null; eventRecord = eventLogReader.ReadEvent())
{
//Console.WriteLine("eventRecord.ActivityId=" + eventRecord.ActivityId);
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------------------------");
Console.WriteLine("Event ID: " + eventRecord.Id);
Console.WriteLine("Logged: " + eventRecord.TimeCreated);
Console.WriteLine(eventRecord.FormatDescription());
}
}
}
protected override void WriteTestScenario()
{
_event1 = WriteSingleEvent("ES", 0, new string('.', 4000)); // chunk 0
_event2 = WriteSingleEvent("ES", 1, new string('.', 4000));
_event3 = WriteSingleEvent("ES", 2, new string('.', 4000), retryOnFail: true); // ptable 1, chunk 1
_event4 = WriteSingleEvent("ES", 3, new string('.', 4000));
WriteSingleEvent("ES", 4, new string('.', 4000), retryOnFail: true); // chunk 2
WriteSingleEvent("ES", 5, new string('.', 4000)); // ptable 2
_event7 = WriteSingleEvent("ES", 6, new string('.', 4000), retryOnFail: true); // chunk 3
TruncateCheckpoint = _event4.LogPosition;
_chunk0 = GetChunkName(0);
_chunk1 = GetChunkName(1);
_chunk2 = GetChunkName(2);
_chunk3 = GetChunkName(3);
Assert.IsTrue(File.Exists(_chunk0));
Assert.IsTrue(File.Exists(_chunk1));
Assert.IsTrue(File.Exists(_chunk2));
Assert.IsTrue(File.Exists(_chunk3));
}
protected override void WriteTestScenario()
{
_prepares1 = new EventRecord[3];
for (int i = 0; i < _prepares1.Length; i++)
{
_prepares1[i] = WriteSingleEvent("AB", i, "test" + i);
}
_prepares2 = new EventRecord[5];
for (int i = 0; i < _prepares2.Length; i++)
{
_prepares2[i] = WriteSingleEvent("CD", i, "test" + i);
}
_prepares3 = new EventRecord[7];
for (int i = 0; i < _prepares3.Length; i++)
{
_prepares3[i] = WriteSingleEvent("EF", i, "test" + i);
}
_delete3 = WriteDelete("EF");
}
public void Deserialize_VerifyEquivalent()
{
var dr = new EventRecord
{
Timestamp = DateTime.Parse("2014-01-20 8:00am"),
MetaData = new Dictionary <int, byte[]> {
{ 1, new byte[] { 1, 2, 3 } }
}
};
var serializer = new DatasourceRecordSerializer();
var ms = new MemoryStream();
serializer.Serialize(ms, new List <DatasourceRecord> {
dr
});
ms.Position = 0;
var records = serializer.Deserialize(ms);
var deserialized = records[0] as EventRecord;
dr.Equivalent(deserialized);
}
public void Basic(string eventPipeFileName)
{
// Initialize
PrepareTestData();
string eventPipeFilePath = Path.Combine(UnZippedDataDir, eventPipeFileName);
Output.WriteLine(string.Format("Processing the file {0}, Making ETLX and scanning.", Path.GetFullPath(eventPipeFilePath)));
var eventStatistics = new SortedDictionary <string, EventRecord>(StringComparer.Ordinal);
using (var traceLog = new TraceLog(TraceLog.CreateFromEventPipeDataFile(eventPipeFilePath)))
{
var traceSource = traceLog.Events.GetSource();
traceSource.AllEvents += delegate(TraceEvent data)
{
string eventName = data.ProviderName + "/" + data.EventName;
if (eventStatistics.ContainsKey(eventName))
{
eventStatistics[eventName].TotalCount++;
}
else
{
eventStatistics[eventName] = new EventRecord()
{
TotalCount = 1,
FirstSeriazliedSample = new String(data.ToString().Replace("\n", "\\n").Replace("\r", "\\r").Take(1000).ToArray())
};
}
};
// Process
traceSource.Process();
}
// Validate
ValidateEventStatistics(eventStatistics, eventPipeFileName);
}
protected override void WriteTestScenario()
{
var t1 = WriteTransactionBegin("ES", ExpectedVersion.NoStream);
var t2 = WriteTransactionBegin("ABC", ExpectedVersion.NoStream);
_p1 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 0, t1.EventStreamId, 0,
"es1" + new string('.', 3000), PrepareFlags.Data);
_p2 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 0, t2.EventStreamId, 0,
"abc1" + new string('.', 3000), PrepareFlags.Data);
_p3 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 1, t1.EventStreamId, 1,
"es1" + new string('.', 3000), PrepareFlags.Data);
_p4 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 1, t2.EventStreamId, 1,
"abc1" + new string('.', 3000), PrepareFlags.Data, retryOnFail: true);
_p5 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 2, t1.EventStreamId, 2,
"es1" + new string('.', 3000), PrepareFlags.Data);
WriteTransactionEnd(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId);
WriteTransactionEnd(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId);
_t2CommitPos = WriteCommit(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId, _p2.EventNumber);
_t1CommitPos = WriteCommit(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId, _p1.EventNumber);
}
public void FormatDescription(string log)
{
if (PlatformDetection.IsWindows7) // Null events in PowerShell log
{
return;
}
var query = new EventLogQuery(log, PathType.LogName, "*[System]")
{
ReverseDirection = true
};
using (var eventLog = new EventLogReader(query, Helpers.GetBookmark(log, PathType.LogName)))
{
using (EventRecord record = eventLog.ReadEvent())
{
Assert.IsType <EventLogRecord>(record);
string description = record.FormatDescription();
Assert.Equal(description, record.FormatDescription(null));
Assert.Equal(description, record.FormatDescription(new List <object>()));
}
}
}
private void DeliverEvent(ResolvedEventRecord @event)
{
EventRecord positionEvent = (@event.Link ?? @event.Event);
var receivedPosition = new EventPosition(@event.CommitPosition, positionEvent.LogPosition);
if (_from >= receivedPosition)
{
throw new Exception(
string.Format(
"ReadFromTF returned events in incorrect order. Last known position is: {0}. Received position is: {1}",
_from, receivedPosition));
}
_publisher.Publish(
new ProjectionMessage.Projections.CommittedEventReceived(
_distibutionPointCorrelationId, receivedPosition, positionEvent.EventStreamId,
positionEvent.EventNumber, @event.Event.EventStreamId, @event.Event.EventNumber, @event.Link != null,
new Event(
@event.Event.EventId, @event.Event.EventType,
(@event.Event.Flags & PrepareFlags.IsJson) != 0, @event.Event.Data, @event.Event.Metadata)));
_from = receivedPosition;
}
public EventRecord GetEventById(int eventId)
{
try
{
EventRecord retrievedEvent = new EventRecord();
using (SqlConnection conn = new SqlConnection(_sqlConnectionString))
{
conn.Open();
string getEventQuery = @"select * from cn.Events where ListingId = @eventId";
using (SqlCommand cmd = new SqlCommand(getEventQuery, conn))
{
cmd.Parameters.AddWithValue("@eventId", eventId);
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
retrievedEvent = new EventRecord()
{
ListingId = Int32.Parse(reader["ListingId"].ToString()),
Title = reader["Title"].ToString(),
Description = reader["Description"].ToString(),
StartTime = DateTime.Parse(reader["StartTime"].ToString()),
EndTime = DateTime.Parse(reader["EndTime"].ToString()),
LocX = float.Parse(reader["LocX"].ToString()),
LocY = float.Parse(reader["LocY"].ToString()),
UserId = Int32.Parse(reader["UserId"].ToString())
};
}
}
}
}
return(retrievedEvent);
}
catch (SqlException e)
{
throw new RepoException(e.Message);
}
}
private EventArrivedEventArgs CreateEventArgsFromEventRecord(EventRecord eventRecord)
{
byte eventOpcode = eventRecord.EventHeader.EventDescriptor.Opcode;
TraceEventInfoWrapper traceEventInfo;
bool shouldDispose = false;
// Find the event information (schema).
int index = this.traceEventInfoCache.IndexOfKey(eventOpcode);
if (index >= 0)
{
traceEventInfo = this.traceEventInfoCache.Values[index];
}
else
{
traceEventInfo = new TraceEventInfoWrapper(eventRecord);
try {
this.traceEventInfoCache.Add(eventOpcode, traceEventInfo);
}
catch (ArgumentException) {
// Some other thread added this entry.
shouldDispose = true;
}
}
// Get the properties using the current event information (schema).
PropertyBag properties = traceEventInfo.GetProperties(eventRecord);
// Dispose the event information because it doesn't live in the cache
if (shouldDispose)
{
traceEventInfo.Dispose();
}
EventArrivedEventArgs args = new EventArrivedEventArgs(eventOpcode, properties);
return(args);
}
protected EventRecord WriteSingleEvent(string eventStreamId, int eventNumber, string data, DateTime?timestamp = null)
{
var prepare = LogRecord.SingleWrite(WriterCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
Guid.NewGuid(),
eventStreamId,
eventNumber - 1,
"some-type",
Encoding.UTF8.GetBytes(data),
null,
timestamp);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
var commit = LogRecord.Commit(WriterCheckpoint.ReadNonFlushed(), prepare.CorrelationId, prepare.LogPosition, eventNumber);
Assert.IsTrue(Writer.Write(commit, out pos));
var eventRecord = new EventRecord(eventNumber, prepare);
return(eventRecord);
}
private void DeliverEvent(EventRecord @event, EventRecord link, float progress)
{
EventRecord positionEvent = (link ?? @event);
if (positionEvent.EventNumber != _fromSequenceNumber)
{
throw new InvalidOperationException(
string.Format(
"Event number {0} was expected in the stream {1}, but event number {2} was received",
_fromSequenceNumber, _streamName, positionEvent.EventNumber));
}
_fromSequenceNumber = positionEvent.EventNumber + 1;
var resolvedLinkTo = positionEvent.EventStreamId != @event.EventStreamId ||
positionEvent.EventNumber != @event.EventNumber;
_publisher.Publish(
//TODO: publish both link and event data
new ProjectionCoreServiceMessage.CommittedEventDistributed(
_distibutionPointCorrelationId, default(EventPosition), positionEvent.EventStreamId,
positionEvent.EventNumber, @event.EventStreamId, @event.EventNumber, resolvedLinkTo,
new Event(@event.EventId, @event.EventType, false, @event.Data, @event.Metadata),
positionEvent.LogPosition, progress));
}
public static Stream Translate(List <CaseObject.CaseEventRecord> records, Stream EventHis)
{
XmlSerializer serializer = new XmlSerializer(typeof(EventHistory));
EventHistory eventHistory = new EventHistory();
EventHis.Seek(0, SeekOrigin.Begin);
List <EventRecord> eventRecList = new List <EventRecord>();
foreach (CaseObject.CaseEventRecord rec in records)
{
EventRecord r = new EventRecord();
r.createTime = rec.createTime;
r.description = rec.description;
eventRecList.Add(r);
}
eventHistory.EventRecord = eventRecList.ToArray();
serializer.Serialize(EventHis, eventHistory);
EventHis.Seek(0, SeekOrigin.Begin);
return(EventHis);
}
private FragmentHeader ReadFragmentHeader(EventRecord record, ref int offset)
{
int signature = BitConverter.ToInt32(this.buffer, offset);
if (signature != FragmentHeader.Signature)
{
throw new FragmentHeaderNotFoundException(string.Format("Fragment Header not found at offset {0} in ElfChnk offset {1}", offset, this.fileOffset), this.fileOffset, record.GetNextRecordOffset());
}
FragmentHeader header = new FragmentHeader(offset);
////After the signature there is an xml token and version of 0x0C01.
////I'll trust that it's there if the signature passes
offset += 6;
header.TemplateId = BitConverter.ToInt32(this.buffer, offset);
offset += 4;
header.TemplateDefinitionOffset = BitConverter.ToInt32(this.buffer, offset);
offset += 4;
return(header);
}
private static void DisplayEventAndLogInformation(EventLogReader logReader)
{
for (EventRecord eventInstance = logReader.ReadEvent();
null != eventInstance; eventInstance = logReader.ReadEvent())
{
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("Event ID: {0}", eventInstance.Id);
Console.WriteLine("Publisher: {0}", eventInstance.ProviderName);
try
{
Console.WriteLine("Description: {0}", eventInstance.FormatDescription());
}
catch (EventLogException)
{
// The event description contains parameters, and no parameters were
// passed to the FormatDescription method, so an exception is thrown.
}
// Cast the EventRecord object as an EventLogRecord object to
// access the EventLogRecord class properties
EventLogRecord logRecord = (EventLogRecord)eventInstance;
Console.WriteLine("Container Event Log: {0}", logRecord.ContainerLog);
}
}
public static bool IsPowerOffEvent(this EventRecord record)
{
var result = false;
switch (record.ProviderName)
{
case SourceEventLog:
result = (EventLogOffInstances.Contains(record.Id));
break;
case SourceKernelPower:
result = (KernelPowerOffInstances.Contains(record.Id));
break;
case SourceKernelGeneral:
result = (KernelGeneralOffInstances.Contains(record.Id));
break;
default:
break;
}
return(result);
}
private void Given()
{
_it = new Core.Services.AwakeReaderService.AwakeService();
var recordFactory = LogFormatHelper <TLogFormat, TStreamId> .RecordFactory;
var streamId = LogFormatHelper <TLogFormat, TStreamId> .StreamId;
_eventRecord = new EventRecord(
100,
LogRecord.Prepare(
recordFactory, 1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, streamId, 99, PrepareFlags.Data,
"event", new byte[0], null, DateTime.UtcNow), "Stream");
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler <TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(3);
_reply3 = new TestMessage(4);
_it.Handle(_eventCommitted);
}
private static EventInfo ConvertEventRecordToEventInfo(EventRecord record, bool includeEventData)
{
var eventInfo = new EventInfo()
{
EventId = record.Id,
LevelDisplayName = GetLevelDisplayName(record.Level), //The LevelDisplayName sometime get EventLogNotFoundException exception
LogName = record.LogName,
MachineName = record.MachineName,
ProviderName = record.ProviderName,
TimeCreated = Utility.ToUniversalTime(record.TimeCreated),
Description = record.FormatDescription(),
Index = record.RecordId,
UserName = record.UserId?.Value,
Keywords = GetKeywords(record.KeywordsDisplayNames),
};
if (includeEventData)
{
eventInfo.EventData = GetEventData(record.Properties);
}
return(eventInfo);
}
private void EnqueueDeliverEvent(EventRecord @event, EventRecord link, float progress, ref int sequenceNumber)
{
if (link != null)
{
throw new Exception();
}
_enqueuedEventDeliveries++;
var positionEvent = @event;
if (positionEvent.EventNumber != sequenceNumber)
{
throw new InvalidOperationException(
string.Format(
"Event number {0} was expected in the stream {1}, but event number {2} was received",
sequenceNumber, SystemStreams.StreamsStream, positionEvent.EventNumber));
}
sequenceNumber = positionEvent.EventNumber + 1;
var item = new DeliverEventOutItem(_ioDispatcher, this, @event, @progress);
EnqueueReadMetaStreamItem(item);
Enqueue(item);
}
public void when_limit_pending_and_sending_message_larger_than_pending_bytes_threshold_but_no_bytes_pending_should_not_close_connection()
{
var messageSize = _connectionPendingSendBytesThreshold + 1000;
var evnt = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now, PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]);
var record = ResolvedEvent.ForUnresolvedEvent(evnt, null);
var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success, record, StreamMetadata.Empty, false, "");
var dummyConnection = new DummyTcpConnection();
dummyConnection.PendingSendBytes = 0;
var tcpConnectionManager = new TcpConnectionManager(
Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(),
InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider(new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1),
TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }, _connectionPendingSendBytesThreshold);
tcpConnectionManager.SendMessage(message);
var data = dummyConnection.ReceivedData.Last();
var receivedPackage = TcpPackage.FromArraySegment(data);
Assert.AreEqual(receivedPackage.Command, TcpCommand.ReadEventCompleted, "Expected ReadEventCompleted but got {0}", receivedPackage.Command);
}
public void addData(EventRecord eventRecord)
{
try
{
IDbCommand dbcmd = getDbCommand();
dbcmd.CommandText =
"INSERT INTO " + TABLE_NAME
+ " ( "
//+ KEY_EventID + ", "
+ KEY_Content + ", "
+ KEY_Amount + " ) "
+ "VALUES ( '"
//+ eventRecord.EventID + "', '"
+ eventRecord.Content + "', '"
+ eventRecord.Amount + "' )";
dbcmd.ExecuteNonQuery();
}
catch
{
Debug.Log("Invalid data key because repeated. Please change a new key");
}
}
/// <summary>
/// Kicks off handling of interesting events by reading
/// metadata from Event XML.
/// </summary>
/// <param name="er"></param>
void ProcessEvent(EventRecord er)
{
WriteInfo(Invariant($"Received event {er.Id} from the subscription."));
var isf = ParseEvent(er);
if (isf.IP == null || !IPAddress.TryParse(isf.IP, out IPAddress ad))
{
WriteInfo("Couldn't read IP address from event. Nothing to do.");
return;
}
// Canonicalize IP
isf.IP = ad.ToString();
if (IsLocalAddress(ad))
{
WriteInfo($"No action required for {isf.IP}, it is a local address.");
return;
}
BlockIpIfNecessary(isf);
}
private ResolvedEvent ResolveLinkToEvent(EventRecord eventRecord, long commitPosition)
{
if (eventRecord.EventType == SystemEventTypes.LinkTo)
{
try
{
string[] parts = Helper.UTF8NoBom.GetString(eventRecord.Data).Split('@');
int eventNumber = int.Parse(parts[0]);
string streamId = parts[1];
var res = _readIndex.ReadEvent(streamId, eventNumber);
if (res.Result == ReadEventResult.Success)
{
return(new ResolvedEvent(res.Record, eventRecord, commitPosition));
}
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error while resolving link for event record: {0}", eventRecord.ToString());
}
}
return(new ResolvedEvent(eventRecord, null, commitPosition));
}
private void OnLoadStateCompleted(ClientMessage.ReadEventsBackwardsCompleted message)
{
EnsureState(State.LoadStateRequsted);
if (message.Events.Length > 0)
{
EventRecord checkpoint = message.Events.FirstOrDefault(v => v.EventType == "ProjectionCheckpoint");
if (checkpoint != null)
{
InitializeProjectionFromCheckpoint(checkpoint);
return;
}
}
if (message.NextEventNumber == -1)
{
InitializeNewProjection();
}
else
{
_nextStateIndexToRequest = message.NextEventNumber;
GoToState(State.LoadStateRequsted);
}
}
private void EnqueueDeliverEvent(EventRecord @event, EventRecord link, float progress, ref long sequenceNumber)
{
if (link != null)
{
throw new Exception();
}
var positionEvent = @event;
if (positionEvent.EventNumber != sequenceNumber)
{
// This can happen when the original stream has $maxAge/$maxCount set
_publisher.Publish(new ReaderSubscriptionMessage.Faulted(EventReaderCorrelationId, string.Format(
"Event number {0} was expected in the stream {1}, but event number {2} was received. This may happen if events have been deleted from the beginning of your stream, please reset your projection.",
sequenceNumber, SystemStreams.StreamsStream, positionEvent.EventNumber), GetType()));
return;
}
sequenceNumber = positionEvent.EventNumber + 1;
var item = new DeliverEventOutItem(_ioDispatcher, this, @event, @progress);
EnqueueReadMetaStreamItem(item);
Enqueue(item);
}
protected override void WriteTestScenario()
{
var t1 = WriteTransactionBegin("ES", ExpectedVersion.NoStream);
var t2 = WriteTransactionBegin("ABC", ExpectedVersion.NoStream);
_p1 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 0, t1.EventStreamId, 0,
"es1" + new string('.', 3000), PrepareFlags.Data);
_p2 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 0, t2.EventStreamId, 0,
"abc1" + new string('.', 3000), PrepareFlags.Data);
_p3 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 1, t1.EventStreamId, 1,
"es1" + new string('.', 3000), PrepareFlags.Data);
_p4 = WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 1, t2.EventStreamId, 1,
"abc1" + new string('.', 3000), PrepareFlags.Data, retryOnFail: true);
_p5 = WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 2, t1.EventStreamId, 2,
"es1" + new string('.', 3000), PrepareFlags.Data);
WriteTransactionEnd(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId);
WriteTransactionEnd(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId);
_t2CommitPos = WriteCommit(t2.CorrelationId, t2.TransactionPosition, t2.EventStreamId, _p2.EventNumber);
_t1CommitPos = WriteCommit(t1.CorrelationId, t1.TransactionPosition, t1.EventStreamId, _p1.EventNumber);
_pos6 = Db.Config.WriterCheckpoint.ReadNonFlushed();
var r6 = LogRecord.Prepare(_recordFactory, _pos6, Guid.NewGuid(), Guid.NewGuid(), _pos6, 0, "t1", -1,
PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
Writer.Write(r6, out _pos7);
var r7 = LogRecord.Prepare(_recordFactory, _pos7, Guid.NewGuid(), Guid.NewGuid(), _pos7, 0, "t1", -1,
PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
Writer.Write(r7, out _pos8);
var r8 = LogRecord.Prepare(_recordFactory, _pos8, Guid.NewGuid(), Guid.NewGuid(), _pos8, 0, "t1", -1,
PrepareFlags.SingleWrite, "et", LogRecord.NoData, LogRecord.NoData);
long pos9;
Writer.Write(r8, out pos9);
}
private void SendEventRecord(EventRecord eventRecord)
{
if (this.InitialPosition == InitialPositionEnum.Timestamp &&
this.InitialPositionTimestamp.HasValue &&
eventRecord.TimeCreated.HasValue &&
this.InitialPositionTimestamp.Value > eventRecord.TimeCreated.Value.ToUniversalTime())
{
return; //Don't send if timetamp initial position is in the future
}
EventRecordEnvelope envelope;
if (this.customFilters.Length > 0)
{
envelope = new EventRecordEnvelope(eventRecord, true, this.bookmarkId); //Need event data for filtering
//Don't send if any filter return false
if (this.customFilters.Any(name => !EventInfoFilters.GetFilter(name)(envelope.Data)))
{
return;
}
//Strip off Event Data if not configured
if (!this.includeEventData)
{
envelope.Data.EventData = null;
}
}
else
{
envelope = new EventRecordEnvelope(eventRecord, this.includeEventData, this.bookmarkId);
}
this.recordSubject.OnNext(envelope);
this._metrics?.PublishCounter(this.Id, MetricsConstants.CATEGORY_SOURCE, CounterTypeEnum.Increment,
MetricsConstants.EVENTLOG_SOURCE_EVENTS_READ, 1, MetricUnit.Count);
}
public FeedbackItemWatsonEntry(EventRecord eventLogRecord)
{
EventTime = eventLogRecord.TimeCreated.Value.ToUniversalTime();
FaultBucket = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
FaultBucketIndex
);
HashedBucket = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
HashedBucketIndex
);
WatsonReportId = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
WatsonReportIdIndex
);
EventName = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
EventNameIndex
);
CabId = EventLogCollector.GetEventRecordPropertyToString(eventLogRecord, CabIdIndex);
ApplicationName = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
ApplicationNameIndex
);
ApplicationVersion = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
ApplicationVersionIndex
);
FaultingModule = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
FaultingModuleIndex
);
FaultingModuleVersion = EventLogCollector.GetEventRecordPropertyToString(
eventLogRecord,
FaultingModuleVersionindex
);
}
private string LinqXElementWriter(EventRecord eventRecord)
{
DateTime timeCreated = (DateTime)eventRecord.TimeCreated;
string eventData = WinLog.LogReader.RetrieveExtendedData(eventRecord.ToXml());
XElement dataItemElement =
new XElement("DataItem",
new XAttribute("type", "System.Event.LinkedData"),
new XAttribute("time", $"{timeCreated.ToUniversalTime():yyyy-MM-ddTHH:mm:ss.ffffffZ}"),
new XAttribute("sourceHealthServiceId", $"{WorkspaceId}"),
new XElement("EventOriginId", "{7C384BE3-8EBD-4B86-A392-357AA34750C5}"),
new XElement("PublisherId", $"{{{(eventRecord.ProviderId ?? Guid.Empty).ToString()}}}"),
new XElement("PublisherName", eventRecord.ProviderName),
new XElement("EventSourceName", eventRecord.ProviderName),
new XElement("Channel", $"{eventRecord.LogName ?? "Unknown"}"),
new XElement("LoggingComputer", eventRecord.MachineName),
new XElement("EventNumber", $"{eventRecord.Id.ToString()}"),
new XElement("EventCategory", $"{(eventRecord.Task ?? 0).ToString()}"),
new XElement("EventLevel", $"{(eventRecord.Level ?? 0).ToString()}"),
new XElement("UserName", "N/A"),
new XElement("RawDescription", string.Empty),
new XElement("LCID", "1033"),
new XElement("CollectDescription", "true"),
new XElement("EventData",
new XElement("DataItem",
new XAttribute("type", "System.XmlData"),
new XAttribute("time", $"{timeCreated.ToUniversalTime():yyyy-MM-ddTHH:mm:ss.ffffffZ}"),
new XAttribute("sourceHealthServiceId", $"{WorkspaceId}"),
eventData)),
new XElement("EventDisplayNumber", $"{eventRecord.Id.ToString()}"),
new XElement("EventDescription", string.Empty),
new XElement("ManagedEntityId", "{D056ADDA-9675-7690-CC92-41AA6B90CC05}"),
new XElement("RuleId", "{1F68E37D-EC73-9BD3-92D5-C236C995FA0A}")
);
return(dataItemElement.ToString(SaveOptions.DisableFormatting));
}
public string UpdateEvent(EventRecord updated)
{
if (DoesEventBelongToUser(updated.ListingId) || LoginRepository.CurrentUser.IsAdmin)
{
try
{
using (SqlConnection conn = new SqlConnection(_sqlConnectionString))
{
conn.Open();
String updateEventQuery = @"update cn.Events
set Title = @title, Description = @description, StartTime = @start, EndTime = @end, LocX = @LocX, LocY = @LocY
where ListingId = @id;";
using (SqlCommand cmd = new SqlCommand(updateEventQuery, conn))
{
cmd.Parameters.AddWithValue("@title", updated.Title);
cmd.Parameters.AddWithValue("@description", updated.Description);
cmd.Parameters.AddWithValue("@start", updated.StartTime);
cmd.Parameters.AddWithValue("@end", updated.EndTime);
cmd.Parameters.AddWithValue("@LocX", updated.LocX);
cmd.Parameters.AddWithValue("@LocY", updated.LocY);
cmd.Parameters.AddWithValue("@id", updated.ListingId);
cmd.ExecuteNonQuery();
}
}
return(string.Format("Successfully updated event {0}", updated.Title));
}
catch (SqlException e)
{
throw new RepoException(e.Message);
}
}
else
{
throw new RepoException("Event does not belong to user!");
}
}
