public override async Task HandleMessage(AuditorWebSocketConnection connection, MessageEnvelope messageEnvelope)
{
var quantaBatch = (QuantaBatch)messageEnvelope.Message;
var quanta = quantaBatch.Quanta;
var quantaBatchCount = quanta.Count;
for (var i = 0; i < quantaBatchCount; i++)
{
var quantumEnvelope = quanta[i];
var quantum = (Quantum)quantumEnvelope.Message;
if (quantum.Apex <= Global.QuantumHandler.LastAddedQuantumApex)
{
continue;
}
if (quantum.Apex != Global.QuantumHandler.LastAddedQuantumApex + 1)
{
logger.Warn($"Batch has invalid quantum apexes (current: {Global.QuantumHandler.LastAddedQuantumApex}, received: {quantum.Apex}). New apex cursor request will be send.");
await connection.SendMessage(new SetApexCursor { Apex = Global.QuantumHandler.LastAddedQuantumApex });
return;
}
_ = Global.QuantumHandler.HandleAsync(quantumEnvelope);
}
}
public override async Task Validate(AuditorWebSocketConnection connection, MessageEnvelope envelope)
{
var request = envelope.Message as RequestMessage;
if (request == null)
{
throw new BadRequestException("Message of RequestMessage was expected");
}
await base.Validate(connection, envelope);
if (!envelope.IsSignedBy(request.AccountWrapper.Account.Pubkey))
{
throw new UnauthorizedException();
}
}
public override async Task Validate(AuditorWebSocketConnection connection, IncomingMessage message)
{
await base.Validate(connection, message);
var clientRequest = (message.Envelope.Message as RequestQuantum)?.RequestEnvelope;
if (clientRequest == null)
{
throw new UnexpectedMessageException("RequestQuantum is expected");
}
if (!clientRequest.AreSignaturesValid())
{
throw new UnauthorizedException();
}
}
public override Task HandleMessage(AuditorWebSocketConnection connection, MessageEnvelope messageEnvelope)
{
//if we got this message than verification succeeded
var alphaState = (AlphaState)messageEnvelope.Message;
logger.Info($"Alpha state is {alphaState.State}");
connection.ConnectionState = ConnectionState.Ready;
//send apex cursor message to start receive quanta
_ = connection.SendMessage(new SetApexCursor()
{
Apex = Global.QuantumStorage.CurrentApex
});
return(Task.CompletedTask);
}
public override async Task HandleMessage(AuditorWebSocketConnection connection, IncomingMessage message)
{
var stateRequestMessage = (AuditorStateRequest)message.Envelope.Message;
var hasQuanta = true;
var aboveApex = stateRequestMessage.TargetApex;
var batchSize = 50;
while (hasQuanta)
{
if (!Context.QuantumStorage.GetQuantaBacth(aboveApex + 1, batchSize, out var currentBatch) &&
(aboveApex + 1 < Context.QuantumStorage.CurrentApex))
{
currentBatch = await Context.PersistenceManager.GetQuantaAboveApex(aboveApex, batchSize); //quanta are not found in the in-memory storage
if (currentBatch.Count < 1)
{
throw new Exception("No quanta from database.");
}
}
if (currentBatch == null)
{
currentBatch = new List <MessageEnvelope>();
}
hasQuanta = currentBatch.Count == batchSize;
var state = new AuditorState
{
State = Context.AppState.State,
PendingQuanta = currentBatch,
HasMorePendingQuanta = hasQuanta
};
await connection.SendMessage(state);
var lastQuantum = currentBatch.LastOrDefault();
aboveApex = lastQuantum?.Message.MessageId ?? 0;
}
;
}
public override async Task HandleMessage(AuditorWebSocketConnection connection, MessageEnvelope messageEnvelope)
{
var stateRequestMessage = (AuditorStateRequest)messageEnvelope.Message;
var allPendingQuanta = await Global.PersistenceManager.GetQuantaAboveApex(stateRequestMessage.TargetApex);
var skip = 0;
var maxQuantaPerMessage = 10;
var hasQuanta = true;
while (hasQuanta)
{
var currentBatch = allPendingQuanta.Skip(skip).Take(maxQuantaPerMessage).ToList();
hasQuanta = (skip + maxQuantaPerMessage) < allPendingQuanta.Count;
skip += maxQuantaPerMessage;
var state = new AuditorState
{
State = Global.AppState.State,
PendingQuanta = currentBatch,
HasMorePendingQuanta = hasQuanta
};
await connection.SendMessage(state);
}
;
}
public override Task HandleMessage(AuditorWebSocketConnection connection, MessageEnvelope messageEnvelope)
{
_ = Global.QuantumHandler.HandleAsync(messageEnvelope);
return(Task.CompletedTask);
}
public override Task HandleMessage(AuditorWebSocketConnection connection, IncomingMessage message)
{
_ = Context.QuantumHandler.HandleAsync(message.Envelope);
return(Task.CompletedTask);
}
public override async Task HandleMessage(AuditorWebSocketConnection connection, IncomingMessage message)
{
//send message back. The message contains handshake data
await connection.SendMessage(message.Envelope.Message);
}
