private static RawEvent ProcessLogMessage(int lineNumber, Match currentLogEntryMatch, IReadOnlyCollection <string> lines)
{
var properties = new Dictionary <string, object>
{
{ "LineNumber", lineNumber },
{ "PID", currentLogEntryMatch.Groups["PID"].Value },
{ "Thread", currentLogEntryMatch.Groups["Thread"].Value }
};
var messageLines = new [] { currentLogEntryMatch.Groups["Message"].Value }.Concat(lines.TakeWhile(line => !ExceptionRegex.Match(line).Success)).ToArray();
var message = string.Join(Environment.NewLine, messageLines);
var messageTemplate = MagicUpTheMessageTemplate(message, properties);
var rawEvent = new RawEvent
{
Timestamp = DateTimeOffset.Parse(currentLogEntryMatch.Groups["Timestamp"].Value),
Level = ConvertLevel(currentLogEntryMatch.Groups["Level"].Value),
Properties = properties,
MessageTemplate = messageTemplate
};
var exceptionLines = lines.Except(messageLines).ToArray();
if (exceptionLines.Any())
{
rawEvent.Exception = string.Join(Environment.NewLine, exceptionLines);
}
return(rawEvent);
}
public void ParseToRaw_ValidRawEvent_ShouldSucceed()
{
// Arrange
const string eventId = "2d1781af-3a4c-4d7c-bd0c-e34b19da4e66";
const string licensePlate = "1-TOM-337";
var originalEvent = new NewCarRegistered(eventId, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(originalEvent.Data, Formatting.Indented);
var rawEvent = new RawEvent(eventId, originalEvent.EventType, rawEventBody, originalEvent.Subject, originalEvent.DataVersion, originalEvent.EventTime);
IEnumerable <RawEvent> events = new List <RawEvent>
{
rawEvent
};
var serializedRawEvents = JsonConvert.SerializeObject(events);
// Act
var eventGridMessage = EventGridParser.Parse <RawEvent>(serializedRawEvents);
// Assert
Assert.NotNull(eventGridMessage);
Assert.NotNull(eventGridMessage.Events);
Assert.Single(eventGridMessage.Events);
var eventPayload = eventGridMessage.Events.Single();
Assert.Equal(eventId, eventPayload.Id);
Assert.Equal(originalEvent.Subject, eventPayload.Subject);
Assert.Equal(originalEvent.EventType, eventPayload.EventType);
Assert.Equal(originalEvent.EventTime, eventPayload.EventTime);
Assert.Equal(originalEvent.DataVersion, eventPayload.DataVersion);
Assert.NotNull(eventPayload.Data);
Assert.Equal(rawEventBody, eventPayload.Data.ToString());
}
private Task On(RawEvent rawEvent, Position?position, DateTime eventCreationTime)
{
var @event = _deserializer.Deserialize(rawEvent);
_log.Debug("Projecting event {event}", rawEvent.Body.ToString());
try
{
// return Measure(() =>// Should be moved to a messenger decorator
// {
var envelopedEvent = new EventEnvelope(
new MessageChainInfo(@event.Id.ToString()
, @event.Metadata.CorrelationId
, @event.Metadata.CausationId)
, @event.Body);
_messenger.Dispatch(envelopedEvent);
return(_checkpointStore.StoreCheckpoint(position));
// }, rawEvent.EventType
// , eventCreationTime
// , _subscriptionName);
}
catch (Exception exception)
{
_log.Error(exception
, "Error occured when projecting the event {event} from {subscriptionName}"
, @event
, _subscriptionName);
throw;
}
}
public async Task PublishSingleTypedRawEventWithDetailedInfo_WithBuilder_ValidParameters_Succeeds()
{
// Arrange
var topicEndpoint = Configuration.GetValue <string>("Arcus:EventGrid:TopicEndpoint");
var endpointKey = Configuration.GetValue <string>("Arcus:EventGrid:EndpointKey");
const string eventSubject = "integration-test";
const string licensePlate = "1-TOM-337";
var eventId = Guid.NewGuid().ToString();
var @event = new NewCarRegistered(eventId, eventSubject, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(@event.Data);
var rawEvent = new RawEvent(@event.Id, @event.EventType, rawEventBody, @event.Subject, @event.DataVersion, @event.EventTime);
// Act
await EventGridPublisherBuilder
.ForTopic(topicEndpoint)
.UsingAuthenticationKey(endpointKey)
.Build()
.PublishRawAsync(rawEvent);
TracePublishedEvent(eventId, @event);
// Assert
var receivedEvent = _serviceBusEventConsumerHost.GetReceivedEvent(eventId);
AssertReceivedNewCarRegisteredEvent(eventId, @event.EventType, eventSubject, licensePlate, receivedEvent);
}
/// <summary>
/// Publish a raw JSON payload as event
/// </summary>
/// <param name="rawEvent">The event to publish</param>
public async Task PublishRawAsync(RawEvent rawEvent)
{
Guard.NotNull(rawEvent, nameof(rawEvent), "No event was specified");
IEnumerable <RawEvent> eventList = new[] { rawEvent };
await PublishEventToTopicAsync(eventList);
}
private static string GetEventUniqueName(RawEvent ev)
{
if (ev.Type == EventType.Sql)
{
return(ev.Key);
}
return(null);
}
private RawEvent Create(string[] a_data)
{
var re = new RawEvent();
re.Id = m_IdSeed++;
re.RawNode = (int.Parse(a_data[0]), int.Parse(a_data[1]));
re.Interval = int.Parse(a_data[2]);
return(re);
}
private static void SaveSqlBodyToFile(RawEvent ev)
{
if (ev.Type == EventType.Sql)
{
string fileName = GetEventUniqueName(ev);
string fullFileName = fileName; // TODO
using (var writer = File.CreateText(fullFileName)) {
}
}
}
private static Activity Create(RawEvent a_rawEvent)
{
var acv = new Activity();
acv.Id = a_rawEvent.Id;
//acv.Duration = a_rawEvent.Interval;
//acv.IsStart = false;
//acv.IsEnd = false;
return(acv);
}
private static string ToJson(IEnumerable <LogEvent> events)
{
var data = new RawEvents
{
Events = events.Select(e => RawEvent.FromLogEvent(e)).ToArray()
};
string json = data.ToJsonString();
return(json);
}
private static string ToJson(IEnumerable <LogEvent> events)
{
var data = new RawEvents
{
Events = events.Select(e => RawEvent.FromLogEvent(e)).ToArray()
};
throw new NotImplementedException();
//string json = data.ToJsonString();
//return json;
}
/// <summary>
/// Publish a raw JSON payload as event
/// </summary>
/// <param name="eventId">Id of the event</param>
/// <param name="eventType">Type of the event</param>
/// <param name="eventBody">Body of the event</param>
/// <param name="eventSubject">Subject of the event</param>
/// <param name="dataVersion">Data version of the event body</param>
/// <param name="eventTime">Time when the event occured</param>
public async Task PublishRawAsync(string eventId, string eventType, string eventBody, string eventSubject, string dataVersion, DateTimeOffset eventTime)
{
Guard.NotNullOrWhitespace(eventId, nameof(eventId), "No event id was specified");
Guard.NotNullOrWhitespace(eventType, nameof(eventType), "No event type was specified");
Guard.NotNullOrWhitespace(eventBody, nameof(eventBody), "No event body was specified");
Guard.NotNullOrWhitespace(dataVersion, nameof(dataVersion), "No data version body was specified");
Guard.For <ArgumentException>(() => eventBody.IsValidJson() == false, "The event body is not a valid JSON payload");
var rawEvent = new RawEvent(eventId, eventType, eventBody, eventSubject, dataVersion, eventTime);
await PublishRawAsync(rawEvent);
}
public void creation()
{
var bytes = new byte[8 * 512];
for (var i = 0; i < bytes.Length; ++i)
{
bytes[i] = (byte)(i * 37);
}
var ev = new RawEvent(1337, bytes);
Assert.AreEqual((uint)1337, (uint)ev.Sequence);
CollectionAssert.AreEqual(bytes, ev.Contents);
}
public EventCategory(RawEvent rawEvent, CategoryOverride categoryOverride, IList <EventCategory> masters) : base(EventType.Category)
{
if (categoryOverride == null)
{
Logger.WarnFormat("unable to find JSON object for event ID: {0}", rawEvent.eventId);
}
_rawEvent = rawEvent;
_categoryOverride = categoryOverride;
_aggregationMaster = null;
if (_categoryOverride != null && masters != null)
{
_aggregationMaster = masters.FirstOrDefault(m => m.Name == _categoryOverride.Name);
}
}
public static RawEvent FromLogEvent(LogEvent e)
{
var re = new RawEvent
{
Timestamp = new DateTimeOffset(e.EventTime),
Level = e.Severity.ToString(),
MessageTemplate = e.FormattedMessage,
Exception = e.GetProperty(LogEvent.ErrorPropertyName)?.ToString(),
};
re.Properties = new Dictionary<string, object>(e.Properties);
re.Properties.Add("source", e.SourceName);
return re;
}
public static RawEvent FromLogEvent(LogEvent e)
{
var re = new RawEvent
{
Timestamp = new DateTimeOffset(e.EventTime),
Level = "info",
MessageTemplate = e.Message.Template,
Exception = e.GetProperty(KnownProperty.Error)?.ToString(),
};
re.Properties = new Dictionary <string, object>(e.Properties);
re.Properties.Add("source", e.SourceName);
return(re);
}
private Task EventAppeared(EventStoreCatchUpSubscription _
, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventType.StartsWith("$"))
{
return(Task.CompletedTask);
}
var @event = new RawEvent(resolvedEvent.Event.EventType
, resolvedEvent.Event.EventId
, resolvedEvent.Event.Metadata
, resolvedEvent.Event.Data);
return(On(@event, resolvedEvent.OriginalPosition, resolvedEvent.Event.Created));
}
public void Parse_ValidRawEvent_ShouldSucceed()
{
// Arrange
const string eventId = "2d1781af-3a4c-4d7c-bd0c-e34b19da4e66";
const string licensePlate = "1-TOM-337";
var originalEvent = new NewCarRegistered(eventId, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(originalEvent.Data);
var rawEvent = new RawEvent(eventId, originalEvent.EventType, rawEventBody, originalEvent.Subject, originalEvent.DataVersion, originalEvent.EventTime);
// Act
var serializedOriginalEvent = JsonConvert.SerializeObject(originalEvent);
var serializedRawEvent = JsonConvert.SerializeObject(rawEvent);
// Assert
Assert.Equal(serializedRawEvent, serializedOriginalEvent);
}
public IEnumerable <RawEvent> Read(IEnumerable <string> lines)
{
RawEvent currentEvent = null;
var inException = false;
var lineNumber = 0;
foreach (var line in lines)
{
lineNumber++;
var match = LineRegex.Match(line);
if (match.Success)
{
inException = false;
if (currentEvent != null)
{
yield return(currentEvent);
}
currentEvent = CreateEventFromMatch(lineNumber, match);
}
else if (currentEvent != null)
{
if (inException || ExceptionRegex.IsMatch(line))
{
currentEvent.Exception += line;
inException = true;
}
else
{
currentEvent.MessageTemplate += "\r\n" + line;
}
}
else
{
yield return(UnexpectedLine(lineNumber, line));
}
}
if (currentEvent != null)
{
yield return(currentEvent);
}
}
public static void InitReceiveEvents()
{
UdpClient listener = new UdpClient(_portToListen);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, _portToListen);
try
{
while (true)
{
Byte[] eventBytes = listener.Receive(ref endPoint);
RawEvent rawEvent = JsonConvert.DeserializeObject <RawEvent>(Encoding.ASCII.GetString(eventBytes));
String[] tagParts = rawEvent.tag.Split('.');
String pais = tagParts[0];
String regiao = tagParts[1];
String nome = tagParts[2];
Int64 aux;
Boolean isNumeric = Int64.TryParse(rawEvent.valor, out aux);
EventData.InsertEvent(_connString, rawEvent, pais, regiao, nome, isNumeric);
MongoEventManager.InsertEvent(new LastEvent()
{
Pais = pais,
Regiao = regiao,
Evento = nome,
Valor = rawEvent.valor,
Data = rawEvent.Data,
IsNumeric = isNumeric
});
}
}
catch (SocketException e)
{
Console.WriteLine(e);
}
finally
{
listener.Close();
}
}
//Пример. В случае тревоги рисует на ячейки прямоугольник залитый произвольным цветом
//и выводит на экран произвольное целое значение как строку
public override void ProcessEvent(Guid chId, RawEvent chEv, bool isAlarm)
{
if (isAlarm)
{
DrawingContext drawingContext = _drawingVisual.RenderOpen();
double curWidth = DrawingPanel.PanelWidth;
double curHeight = DrawingPanel.PanelHeight;
var sampleRect = new Rect(0.3, 0.3, 0.4, 0.4);
Rect normalRect = new Rect(
sampleRect.X * curWidth,
sampleRect.Y * curHeight,
sampleRect.Width * curWidth,
sampleRect.Height * curHeight
);
drawingContext.DrawRectangle(
new SolidColorBrush(ConvertGuidToColor(Guid.NewGuid())),
new Pen(Brushes.Yellow, 2.0),
normalRect
);
var formattedText = new FormattedText(
ConvertGuidToMyStringId(Guid.NewGuid()),
CultureInfo.GetCultureInfo("ru-RU"),
FlowDirection.LeftToRight,
new Typeface("Verdana"),
20,
Brushes.Red);
drawingContext.DrawText(formattedText, new Point(normalRect.X + normalRect.Width / 2, normalRect.Y));
drawingContext.Close();
}
}
public void Write(RawEvent entry)
{
_logs.Add(entry);
}
private TraceContent ParseContent()
{
var events = new List <RawEvent>();
var strings = new Dictionary <ulong, string>();
var stackInfo = new Dictionary <ulong, RawEvent>();
var version = ParseHeader();
var frequency = 0L;
var timers = new HashSet <ulong>();
using var progress = _registry?.Start("Load trace", "Read and parse the binary trace data");
var end = _reader.BaseStream.Length;
while (Position < end)
{
if (!(progress is null))
{
progress.PercentComplete = Position / (float)end;
}
var eventStartPosition = Position;
var eventTypeAndArgsCount = _reader.ReadByte();
var type = (EventType)(eventTypeAndArgsCount & ~(0b11 << 6));
var argsCount = (eventTypeAndArgsCount >> 6) + 1;
var inlineArgs = (byte)4;
if (version < 1007)
{
argsCount++;
inlineArgs++;
}
if (type == EventType.None || EventDescription.Of(type).MinVersion > version)
{
throw new InvalidTraceException("unknown type");
}
if (type == EventType.String)
{
// String dictionary entry [ID, length, string].
var id = ReadVal();
if (id == 0)
{
throw new InvalidTraceException($"{Position} has invalid id 0");
}
if (strings.ContainsKey(id))
{
throw new InvalidTraceException($"{Position} has duplicate id {id}");
}
var value = ReadStr();
if (value.Length == 0)
{
throw new InvalidTraceException($"{Position} has invalid length 0");
}
strings[id] = value;
continue;
}
var ev = new RawEvent(type, (int)eventStartPosition);
if (argsCount < inlineArgs)
{
ev.Args = new ulong[argsCount];
for (var i = 0; i < argsCount; i++)
{
ev.Args[i] = ReadVal();
}
}
else
{
var evLength = ReadVal();
var start = _reader.BaseStream.Position;
var buffer = new List <ulong>();
while (evLength > (ulong)(_reader.BaseStream.Position - start))
{
var arg = ReadVal();
buffer.Add(arg);
}
if (evLength != (ulong)(Position - start))
{
throw new InvalidTraceException(
$"event has wrong length at {Position}, want: {evLength}, got: {Position - start}");
}
ev.Args = buffer.ToArray();
}
if (ev.Type == EventType.UserLog)
{
ev.StringArgs = new[] { ReadStr() }
}
;
switch (ev.Type)
{
case EventType.Frequency:
frequency = (long)ev.Args[0];
if (frequency <= 0)
{
throw new TimeOrderException();
}
break;
case EventType.TimerGoroutine:
timers.Add(ev.Args[0]);
break;
case EventType.Stack:
if (ev.Args.Length < 2)
{
throw new InvalidTraceException("Stack event should have at least 2 arguments");
}
var size = ev.Args[1];
if (size > 1000)
{
throw new InvalidTraceException($"Stack event bad number of frames {size}");
}
var want = version < 1007 ? 4 + 4 * size : 2 + 4 * size;
if (ev.Args.Length != (int)want)
{
throw new InvalidTraceException(
$"Stack event has wrong number of arguments want {want} got {ev.Args.Length}");
}
stackInfo[ev.Args[0]] = ev;
break;
default:
events.Add(ev);
break;
}
}
return(new TraceContent(events, strings, version, frequency, timers, stackInfo));
}
public UntypedEventEnvelope Deserialize(RawEvent e)
{
return(_serializationInterpreter.Deserialize(_configs, e));
}
/// <summary>
/// Sends an event to the CEP Server
/// </summary>
/// <param name="obj">the event</param>
public void SendEvent(RawEvent obj)
{
Log.DebugFormat("Received Event #{1} at {2}: {0}", obj.ToString(), ++eventsReceivedCount, this.GetHashCode());
obj.TimeStamp = DateTime.Now.ToString("yyyyMMddHHmmssffff");
epService.EPRuntime.SendEvent(obj);
}
static void Main(string[] args)
{
List <RawEvent> events = new List <RawEvent>();
List <Guard> guards = new List <Guard>();
Guard guard = null;
string line;
int currentGuardID = -1;
using (System.IO.StreamReader input = new System.IO.StreamReader(@"C:\Users\juric\OneDrive\Desktop\inputDay4.txt"))
{
while ((line = input.ReadLine()) != null)
{
DateTime date = DateTime.ParseExact("1518" + line.Substring(5, 12), "yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture);
events.Add(new RawEvent()
{
Data = line.Substring(19),
Time = date
});
}
}
List <RawEvent> sorted = events.OrderBy(x => x.Time).ToList();
for (int i = 0; i < events.Count; i++)
{
RawEvent tempRE = sorted[i];
if (tempRE.Data.EndsWith(" begins shift"))
{
currentGuardID = int.Parse(tempRE.Data.Replace("Guard #", "").Replace(" begins shift", ""));
guard = guards.FirstOrDefault(x => x.ID == currentGuardID);
if (guard == null)
{
guard = new Guard()
{
ID = currentGuardID,
Month = tempRE.Time.Month,
Date = tempRE.Time.Day
};
guards.Add(guard);
}
}
else if (tempRE.Data == "falls asleep")
{
if (i + 1 < sorted.Count && sorted[i + 1].Data == "wakes up")
{
for (int j = tempRE.Time.Minute; j < sorted[i + 1].Time.Minute; j++)
{
guard.Status[j]++;
}
}
}
}
List <Guard> sortedGuards = guards.OrderBy(x => x.FormatedDate).ToList();
List <Guard> sortedMinGuards = guards.OrderBy(x => x.MinAsleep).ToList();
int max = -1;
int maxID = -1;
int maxMinute = 1;
//task 1
Guard firstGuard = sortedMinGuards[sortedMinGuards.Count - 1];
for (int min = 0; min < 60; min++)
{
int minutes = firstGuard.Status[min];
if (minutes > max)
{
maxID = firstGuard.ID;
max = minutes;
maxMinute = min;
}
}
Console.WriteLine("Prvi odgovor: " + maxID * maxMinute);
//task 2
foreach (Guard g in sortedGuards)
{
for (int mi = 0; mi < 60; mi++)
{
int minutes = g.Status[mi];
if (minutes > max)
{
maxID = g.ID;
max = minutes;
maxMinute = mi;
}
}
}
Console.WriteLine("Drugi odgovor: " + maxID * maxMinute);
}
private static void ThrowRawEventParseError(RawEvent rawEvent)
{
throw new Exception($"Błąd podczas tworzenia zależności zdarzeń: ID:{rawEvent.Id}"
+ $"Następstwo zdarzeń: i:{rawEvent.RawNode.i} j:{rawEvent.RawNode.j}");
}
public virtual UntypedEventEnvelope Deserialize(ContextSchemaConfigs configs, RawEvent resolvedEvent)
{
var jsonMetadata = Encoding.UTF8.GetString(resolvedEvent.Metadata);
var metadata = JsonConvert.DeserializeObject <UntypedEventEnvelope.EventMetadata>(jsonMetadata);
var jsonData = Encoding.UTF8.GetString(resolvedEvent.Body);
var dataType = configs.GetType(resolvedEvent.EventType);
var data = JsonConvert.DeserializeObject(jsonData, dataType);
return(new UntypedEventEnvelope(resolvedEvent.EventId
, metadata
, (IDomainEvent)data));
}
/// <summary>
/// Sends an event to the CEP Server
/// </summary>
/// <param name="obj">the event</param>
public void SendEvent(RawEvent obj)
{
Log.DebugFormat("Received Event #{1} at {2}: {0}", obj.ToString(), ++eventsReceivedCount, this.GetHashCode());
epService.EPRuntime.SendEvent(obj);
}
