public void DisplayText(NetworkEvent ne)
{
this.m_Image = null;
DateTime time = new DateTime(ne.timeIndex);
this.infoLabel.Text = "";
this.appendText("Sender: " + ne.source);
this.appendText("Time: " + time.ToLongDateString() + " " + time.ToLongTimeString());
if (ne is NetworkChunkEvent)
{
NetworkChunkEvent nce = ne as NetworkChunkEvent;
this.appendText("Category: Chunk");
this.appendText("Message Sequence: " + nce.chunk.MessageSequence);
this.appendText("Chunk Sequence: " + nce.chunk.ChunkSequence);
this.appendText("First Chunk Sequence of Message: " + nce.chunk.FirstChunkSequenceOfMessage);
this.appendText("Number of Chunks: " + nce.chunk.NumberOfChunksInMessage);
}
else if (ne is NetworkMessageEvent)
{
NetworkMessageEvent nme = ne as NetworkMessageEvent;
this.appendText("Category: Message");
this.displayMessageEventRecursive(nme.message);
}
else if (ne is NetworkNACKMessageEvent)
{
}
else
{
//Unknown
this.infoLabel.Text = "Unknown Type";
}
this.doubleBufferPanel.Invalidate();
}
public NetworkPlayback(string filename)
{
ChunkAssembler assembler = new ChunkAssembler();
NetworkArchiver archiver = new NetworkArchiver();
archiver.OpenArchive(filename);
while (archiver.HasMoreEvents())
{
//Get the current event
NetworkEvent ne = archiver.GetNextEvent();
if (ne != null)
{
//Add it to the chunkEvents (which contains everything)
this.chunkEvents.Add(ne);
if (ne is NetworkChunkEvent)
{
NetworkChunkEvent nce = (NetworkChunkEvent)ne;
//Add it to the chunk assembler
Message m = assembler.Add(nce.chunk);
if (m != null)
{
//We have a complete message!
NetworkMessageEvent nme = new NetworkMessageEvent(m, ne.timeIndex, ne.source);
this.messageEvents.Add(nme);
}
}
else if (ne is NetworkMessageEvent)
{
this.messageEvents.Add(((NetworkMessageEvent)ne).message);
}
else
{
//Skip
}
}
}
archiver.CloseArchive();
}
public MessageKey(NetworkMessageEvent networkMsgEvt) :
this(networkMsgEvt.MessageId, networkMsgEvt.MessageType, networkMsgEvt.MessageDirection)
{
}
void GetEvents(MessagePrefixesPair msgPfx, Queue <Event> buffer)
{
var msg = msgPfx.Message;
if (msgPfx.Prefixes.Contains(devToolsNetworkEventPrefix))
{
var m = DevTools.Events.LogMessage.Parse(msg.Text);
if (m != null)
{
ActivityEventType? type = null;
DevTools.Events.Network.Base basePayload = null;
string displayName = null;
string host = null;
List <ActivityPhase> phases = null;
if (m.EventType == DevTools.Events.Network.RequestWillBeSent.EventType)
{
type = ActivityEventType.Begin;
var payload = m.ParsePayload <DevTools.Events.Network.RequestWillBeSent>();
basePayload = payload;
if (payload?.request?.url != null)
{
string methodPart = payload.request.method;
methodPart = string.IsNullOrEmpty(methodPart) ? "" : (methodPart + " ");
string urlPart = payload.request.url;
Uri uri;
if (Uri.TryCreate(payload.request?.url, UriKind.Absolute, out uri) &&
!(uri.PathAndQuery == "" || uri.PathAndQuery == "/"))
{
urlPart = uri.PathAndQuery;
host = uri.Host;
}
displayName = string.Format("{0}{1}", methodPart, urlPart);
}
}
else if (m.EventType == DevTools.Events.Network.LoadingFinished.EventType)
{
type = ActivityEventType.End;
}
else if (m.EventType == DevTools.Events.Network.LoadingFailed.EventType)
{
type = ActivityEventType.End;
displayName = "Failed";
}
else if (m.EventType == DevTools.Events.Network.ResponseReceived.EventType)
{
type = ActivityEventType.Milestone;
var payload = m.ParsePayload <DevTools.Events.Network.ResponseReceived>();
basePayload = payload;
if (payload?.response.timing != null)
{
phases = CreatePhases(payload);
}
displayName = "Response received";
}
else if (m.EventType == DevTools.Events.Network.DataReceived.EventType)
{
type = ActivityEventType.Milestone;
var payload = m.ParsePayload <DevTools.Events.Network.DataReceived>();
basePayload = payload;
displayName = string.Format("Data received {0} bytes", payload?.dataLength);
}
else if (m.EventType == DevTools.Events.Network.WebSocketCreated.EventType)
{
type = ActivityEventType.Begin;
var payload = m.ParsePayload <DevTools.Events.Network.WebSocketCreated>();
basePayload = payload;
if (payload != null)
{
displayName = string.Format("WebSocket: {0}", payload.url);
Uri uri;
if (Uri.TryCreate(payload.url ?? "", UriKind.Absolute, out uri))
{
host = uri.Host;
}
}
}
else if (m.EventType == DevTools.Events.Network.WebSocketClosed.EventType)
{
type = ActivityEventType.End;
displayName = "WebSocket closed";
}
else
{
type = ActivityEventType.Milestone;
displayName = m.EventType;
}
if (basePayload == null)
{
basePayload = m.ParsePayload <DevTools.Events.Network.Base>();
}
if (basePayload?.requestId != null)
{
displayName = displayName ?? basePayload.requestId;
string pidTag = DevTools.Events.Network.Base.ParseRequestPid(basePayload.requestId);
var netEvt = new NetworkMessageEvent(msg, displayName, basePayload.requestId, type.Value, NetworkMessageDirection.Outgoing);
netEvt.SetTags(GetRequestTags(basePayload.frameId, host, pidTag));
netEvt.Phases = phases;
buffer.Enqueue(netEvt);
if (netEvt.Type == ActivityEventType.End)
{
requestEnds[netEvt.ActivityId] = netEvt;
}
// sometimes responseReceived follows loadingFinished.
// in order not to lose phases, patch end event generated by loadingFinished.
if (phases != null)
{
NetworkMessageEvent requestEnd;
if (requestEnds.TryGetValue(netEvt.ActivityId, out requestEnd))
{
requestEnd.Phases = phases;
}
}
// GC requestEnds
if (requestEnds.Count > 1024)
{
var oldKeys = requestEnds
.OrderBy(x => ((Message)x.Value.Trigger).Timestamp)
.Take(requestEnds.Count / 2)
.Select(x => x.Key)
.ToList();
oldKeys.ForEach(k => requestEnds.Remove(k));
}
}
}
}
}
void GetEvents(Message msg, Queue <Event> buffer)
{
if (msg.ObjectType == Message.ENTRY)
{
switch (msg.MessageType.Value)
{
case Message.START:
HashSet <string> tags = null;
string displayName = msg.Text;
if (parser.TryParseStart(msg.Text, out var start))
{
if (Uri.TryCreate(start.Url, UriKind.Absolute, out var uri))
{
tags = GetTags(uri.Host);
}
displayName = string.Format("{0} {1}", start.Method, start.Url);
}
var startEvt = new NetworkMessageEvent(msg, displayName, msg.ObjectId, ActivityEventType.Begin, NetworkMessageDirection.Outgoing);
if (tags != null)
{
startEvt.SetTags(tags);
}
buffer.Enqueue(startEvt);
phases[msg.ObjectId.Value] = new EntryPhases()
{
list = new List <ActivityPhase>(),
lastPhaseTs = msg.Timestamp
};
break;
case Message.END:
ActivityStatus status;
statuses.TryGetValue(msg.ObjectId.Value, out status);
var endEvt = new NetworkMessageEvent(msg, msg.Text, msg.ObjectId, ActivityEventType.End, NetworkMessageDirection.Outgoing, status: status);
EntryPhases entryPhases;
if (phases.TryGetValue(msg.ObjectId.Value, out entryPhases))
{
endEvt.Phases = entryPhases.list;
phases.Remove(msg.ObjectId.Value);
}
buffer.Enqueue(endEvt);
break;
case Message.BLOCKED:
RecordPhase(msg, 2);
break;
case Message.DNS:
RecordPhase(msg, 0);
break;
case Message.CONNECT:
RecordPhase(msg, 4);
break;
case Message.SEND:
RecordPhase(msg, 3);
break;
case Message.WAIT:
RecordPhase(msg, 5);
break;
case Message.SSL:
RecordPhase(msg, 1);
break;
case Message.RECEIVE:
RecordStatus(msg);
break;
}
}
}