public void Update(float deltaTime)
{
// queues are swapped so that any new events added in response to an
// event firing are processed in the next frame
m_readIndex = (m_readIndex + 1) & 1;
m_writeIndex = (m_writeIndex + 1) & 1;
if (ReadQueue.Count == 0)
{
return;
}
var count = 0;
m_eventDispatchTimer.Restart();
while (ReadQueue.Count > 0)
{
var evt = ReadQueue.First();
ReadQueue.RemoveAt(0);
TriggerEvent(evt);
count++;
}
Log.Trace("Processed {0} events in {1:F4}s", count,
m_eventDispatchTimer.Elapsed.TotalSeconds);
}
private void ReadMessages()
{
while (true)
{
try
{
var message = JsonConvert.DeserializeObject <Message>(_reader.ReadString());
ReadQueue.Add(message);
if (string.Equals(message.MessageType, "TestHost.Acknowledge"))
{
_ackWaitHandle.Set();
ReadQueue.CompleteAdding();
break;
}
}
catch (Exception ex)
{
TestHostTracing.Source.TraceEvent(
TraceEventType.Error,
0,
"[ReportingChannel]: Waiting for message failed {0}",
ex);
throw;
}
}
}
public void Process(CancellationToken ct)
{
while (CanRead)
{
ct.ThrowIfCancellationRequested();
while (!WriteQueue.IsEmpty && !ReadQueue.IsEmpty)
{
if (TryWriteNext())
{
ReportNextBlockProgress();
}
}
ReadNext();
}
ReadQueue.Close();
while (TryWriteNext())
{
ReportNextBlockProgress();
}
Finish();
}
public void Shutdown()
{
Log.Trace("EventManager Shutting Down");
m_listeners.Clear();
ReadQueue.Clear();
WriteQueue.Clear();
}
/// <summary>
/// Refreshes this descriptor
/// </summary>
/// <param name="queue"></param>
public override void Refresh(ReadQueue queue)
{
base.Refresh(queue);
var handle = queue.With<IDevice>(DeviceInstance, ObjectIdentifier);
handle.Enqueue(dev => dev.DatabaseRevision,
rev => this.DatabaseRevision = (byte)rev,
err => this.DatabaseRevision = null);
}
private void Dispose(bool dispose)
{
ReadQueue.Clear();
AppendQueue.Clear();
ReadQueue.Dispose();
AppendQueue.Dispose();
_disposed = true;
}
/// <summary>
/// Refreshes this descriptor
/// </summary>
/// <param name="queue"></param>
public override void Refresh(ReadQueue queue)
{
base.Refresh(queue);
var handle = queue.With <IDevice>(DeviceInstance, ObjectIdentifier);
handle.Enqueue(dev => dev.DatabaseRevision,
rev => this.DatabaseRevision = (byte)rev,
err => this.DatabaseRevision = null);
}
/// <summary>
/// Data received handler.
/// </summary>
/// <param name="sender">[in]</param>
/// <param name="args">[in]</param>
private void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs args)
{
var count = Port.BytesToRead;
var bytes = new byte[count];
Port.Read(bytes, 0, count);
foreach (var data in bytes)
{
ReadQueue.Add(data);
}
}
public long?Read()
{
if (ReadQueue.Any())
{
return(ReadQueue.Dequeue());
}
else
{
return(null);
}
}
/// <summary>
/// 处理已经解析出来的命令。
/// </summary>
private void HandleReceiveCmds()
{
while (ReadQueue.Count > 0)
{
Log(Name, string.Format("将收到得消息丢给上层处理，时间：{0}", DataTime2String(DateTime.Now)));
Packet packet = ReadQueue.Dequeue() as Packet;
if (packet != null)
{
HandleCmd(packet);
}
}
}
void ProcessBufferedIO(bool force = false)
{
BufferedIO io;
while (WriteQueue.Count > 0)
{
io = WriteQueue.Peek();
// This means we wanted to wait until all the writes had been flushed
// before we attempt to generate the hash of a given piece.
if (io.manager == null && io.buffer == null)
{
io = WriteQueue.Dequeue();
io.tcs.SetResult(true);
continue;
}
if (!force && !WriteLimiter.TryProcess(io.count))
{
break;
}
io = WriteQueue.Dequeue();
try {
Interlocked.Add(ref pendingWrites, -io.count);
Write(io.manager, io.offset, io.buffer, io.count);
io.tcs.SetResult(true);
} catch (Exception ex) {
io.tcs.SetException(ex);
}
}
while (ReadQueue.Count > 0)
{
if (!force && !ReadLimiter.TryProcess(ReadQueue.Peek().count))
{
break;
}
io = ReadQueue.Dequeue();
try {
Interlocked.Add(ref pendingReads, -io.count);
var result = Read(io.manager, io.offset, io.buffer, io.count);
io.tcs.SetResult(result);
} catch (Exception ex) {
io.tcs.SetException(ex);
}
}
}
// dispatches all pending messages in the read queue
private void DispatchMessages()
{
var count = 0;
while (ReadQueue.Count > 0)
{
var msg = ReadQueue.First();
ReadQueue.RemoveAt(0);
TriggerMessage(msg);
count++;
}
Log.VerboseFmtIf(count > 0,
"{0} dispatched {1} messages", Parent.FullName, count);
}
public override void ReadNext()
{
if (fileMetadata.TryGetNextRecord(out var record))
{
var block = Block.CreateBlockForDecompression(record.Start, record.Length, record.StartCompressed, record.LengthCompressed);
input.Position = record.StartCompressed;
input.Read(block.Content, 0, block.Size);
ReadQueue.Enqueue(block);
}
else
{
_canRead = false;
}
}
public override void ReadNext()
{
var start = input.Position;
var left = input.Length - input.Position;
var nextBlockSize = blockSize < left ? blockSize : (int)left;
var block = Block.CreateBlockForCompression(start, nextBlockSize);
input.Read(block.Content, 0, nextBlockSize);
ReadQueue.Enqueue(block);
readBlocks++;
}
internal async ReusableTask <bool> ReadAsync(ITorrentData manager, long offset, byte [] buffer, int count)
{
Interlocked.Add(ref pendingReads, count);
await IOLoop;
if (ReadLimiter.TryProcess(count))
{
Interlocked.Add(ref pendingReads, -count);
return(Read(manager, offset, buffer, count));
}
else
{
var tcs = new ReusableTaskCompletionSource <bool>();
ReadQueue.Enqueue(new BufferedIO(manager, offset, buffer, count, tcs));
return(await tcs.Task);
}
}
public void TakeOneStep()
{
if (IsFinished)
{
return;
}
if (IsWaiting && ReadQueue.Any())
{
IsWaiting = false;
}
var currentInstruction = Instructions[CurrentIndex];
Log($"{ProgramId}: {currentInstruction.GetType().Name}");
var indexBeforeChange = CurrentIndex;
currentInstruction.Perform(this);
if (!IsWaiting && CurrentIndex == indexBeforeChange)
{
CurrentIndex++;
}
}
public void Dispose()
{
// Wait for a graceful disconnect - drain the queue until we get an 'ACK'
Message message;
while (ReadQueue.TryTake(out message, millisecondsTimeout: 1))
{
}
if (_ackWaitHandle.Wait(TimeSpan.FromSeconds(10)))
{
TestHostTracing.Source.TraceInformation("[ReportingChannel]: Received for ack from test host");
}
else
{
TestHostTracing.Source.TraceEvent(
TraceEventType.Error,
0,
"[ReportingChannel]: Timed out waiting for ack from test host");
}
Socket.Dispose();
}
/// <summary>
/// Refresh the descriptor
/// </summary>
/// <param name="queue">The read queue</param>
public virtual void Refresh(ReadQueue queue)
{
var handle = queue.With <INamedObject>(DeviceInstance, ObjectIdentifier);
handle.Enqueue(obj => obj.ObjectName, name => this.Name = name);
}
public T Pop()
{
return(ReadQueue.Pop());
}
public T Peek()
{
return(ReadQueue.Peek());
}
private void FinishReadBody(IAsyncResult result)
{
try
{
var data = result.AsyncState as RsvData;
if (data == null)
{
LogError(Name, "data = null FinishReadBody");
}
else
{
var stream = data.Stream;
var size = stream.EndRead(result);
data.Offset = data.Offset + size;
if (data.Offset < data.DataLength)
{
data.Stream.BeginRead(
data.Data,
data.Offset,
data.DataLength - data.Offset,
FinishReadBody,
data);
}
else
{
TmpReadCmdNumber++;
Log(Name,
string.Format("接收完消息，时间：{0}，第 {1} 个命令", DataTime2String(DateTime.Now), TmpReadCmdNumber));
LastServerHeartBeat = DateTime.Now;
LastClientHeartBeat = DateTime.Now;
var cmd = ParseCmd(data.Data);
ReadQueue.Enqueue(cmd);
if (TmpReadCmdNumber < MaxReadCmdNumberPerFrame)
{
if (Client.Available > 4)
{
StartReadHeader();
}
else
{
IsReading = false;
}
}
else
{
LogWarning(Name, string.Format("这一帧不再接收命令了,时间：{0}", DateTime.Now));
IsReading = false;
}
}
}
}
catch (Exception exception)
{
LogError(Name, string.Format("{0},{1}", exception.Message, exception.StackTrace));
HasConnectedToServer = false;
EventQueue.Enqueue(new Event {
Type = EventType.DisConnect
});
}
}
/// <summary>
/// Read data from SerialPort.
/// </summary>
/// <param name="data">[out]Data byte.</param>
/// <returns>Bool - Return true for success.</returns>
public bool Read(out byte data)
{
return(ReadQueue.Take(out data));
}
