private void HandleIncomingEvents(EventReceive eventReceive)
{
if (eventReceive != null)
{
// Convert submission
string strMsg = string.Empty;
var obj = KubeMQ.SDK.csharp.Tools.Converter.FromByteArray(eventReceive.Body);
Submission submission = (Submission)obj;
// get account
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(Configuration["AccountManagementURL"]);
httpClient.DefaultRequestHeaders.Add("Accept", "text/json");
var response = httpClient.GetAsync($"MeteringUnit/{submission.MeteringUnit.MeteringUnitId}").Result;
var meteringUnit = JsonConvert.DeserializeObject <MeteringUnit>(response.Content.ReadAsStringAsync().Result);
// Save accountConsumption
accountConsumptionService.PostAccountConsumption(new AccountConsumption()
{
Price = submission.SubmissionPrice,
RessourceUsage = submission.RessourceUsage,
Type = submission.MeteringUnit.Type,
UnitOfMeassure = submission.UnitOfMeassure,
Account = new Account()
{
AccountId = meteringUnit.AccountId
},
TimeStamp = DateTime.Now,
EventSequence = eventReceive.Sequence,
});
}
}
internal void OnReceived(StreamBuffer buffer)
{
if (_methodSelector == null || _methodSelector.Invoke(buffer) == false)
{
EventReceive?.Invoke(new IOEventResult(this, IOEventType.Read, buffer.Buffer, 0, buffer.WrittenBytes, AegisResult.Ok));
}
}
public EventsReceiveMessage(EventReceive message)
{
this.Id = message.EventID;
this.Channel = message.Channel;
this.Body = Convertors.ToByteArray(message.Body);
this.Metadata = message.Metadata;
this.Tags = Convertors.FromMapFields(message.Tags);
}
/// <summary>
/// 收到消息时
/// </summary>
public void OnReceive(QQEventArgs <ReceivePacket> e)
{
if (QQGlobal.DebugLog)
{
MessageLog($"接收数据:{Util.ToHex(e.ReceivePacket.buffer)}");
}
EventReceive?.Invoke(this, e);
}
private void HandleIncomingEvents(EventReceive @event)
{
if (@event != null)
{
string strMsg = string.Empty;
object body = KubeMQ.SDK.csharp.Tools.Converter.FromByteArray(@event.Body);
logger.LogInformation($"Subscriber Received Event: Metadata:'{@event.Metadata}', Channel:'{@event.Channel}', Body:'{strMsg}'");
}
}
private async void HandleIncomingEvents(EventReceive eventReceive, string id)
{
try
{
if (OnConsumed != null)
{
await OnConsumed(id, eventReceive.Body, eventReceive.Channel,
eventReceive.Tags.ContainsKey("ForceBytes"),
eventReceive.Tags
);
}
}
catch (Exception e)
{
_logger.LogError(e, "Can`t process incoming event");
}
}
private void HandleIncomingEvents(EventReceive eventReceive)
{
if (eventReceive != null)
{
// Convert submission
string strMsg = string.Empty;
var obj = KubeMQ.SDK.csharp.Tools.Converter.FromByteArray(eventReceive.Body);
Submission submission = (Submission)obj;
// Save accountConsumption
statusConsumptionService.PostStatusConsumption(new StatusConsumption()
{
EventSequence = eventReceive.Sequence,
RessourceUsage = submission.RessourceUsage,
Type = submission.MeteringUnit.Type,
UnitOfMeassure = submission.UnitOfMeassure,
Location = submission.MeteringUnit.Location,
TimeStamp = DateTime.Now
});
}
}
private async Task OnMessageReceive(string message)
{
var payload = JsonConvert.DeserializeObject <GatewayPayload>(message);
if (payload.EventName is null)
{
_logger.LogInformation("[{0}]", payload.Opcode.ToString().ToUpperInvariant());
}
else
{
_logger.LogInformation("[{0} - {1}]", payload.Opcode.ToString().ToUpperInvariant(), payload.EventName);
}
SetSequenceNumber(payload.SequenceNumber);
_lastMessageTime = Environment.TickCount;
switch (payload.Opcode)
{
case GatewayOpCode.Hello:
{
SetCancellationToken();
var heartbeatInterval = JsonConvert.DeserializeObject <HeartbeatEvent>(
payload.EventData.ToString()).HeartbeatInterval;
_heartbeatTask = RunHeartbeat(heartbeatInterval);
}
break;
case GatewayOpCode.Reconnect:
{
CloseHeartbeating();
await CreateConnectionAsync(WebSocketCloseStatus.NormalClosure);
}
break;
case GatewayOpCode.Heartbeat:
{
_logger.LogWarning("Server requested manual heartbeat!");
var heartbeatEvent = new GatewayPayload
{
Opcode = GatewayOpCode.Heartbeat,
EventData = _sequenceNumber ?? null,
};
var heartbeatEventBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(heartbeatEvent));
await _discordSocketClient.SendAsync(heartbeatEventBytes, true);
}
break;
case GatewayOpCode.HeartbeatAck:
{
if (_heartbeatTimes.TryDequeue(out long time))
{
int latency = (int)(Environment.TickCount - time);
int before = _latency;
_latency = latency;
_logger.LogWarning("Latency: old - {0}ms | new - {1}ms", before, _latency);
}
}
break;
case GatewayOpCode.InvalidSession:
{
_logger.LogWarning("Cannot resume session!");
CloseHeartbeating();
if (bool.TryParse(payload.EventData.ToString(), out bool canBeResumed) && canBeResumed)
{
await CreateConnectionAsync(WebSocketCloseStatus.NormalClosure);
}
else
{
// Delete old session id
_clientInfoRepository.DeleteClientInfo();
SetSequenceNumber(0);
await Task.Delay(new Random().Next(1, 6) * 1000);
await CreateConnectionAsync(WebSocketCloseStatus.EndpointUnavailable);
}
}
break;
case GatewayOpCode.Dispatch:
{
await EventReceive.Invoke(payload);
}
break;
default:
_logger.LogWarning("Received unhandled event! - {0} {1} {2}", payload.Opcode.ToString().ToUpperInvariant(),
payload.EventName ?? string.Empty, payload.EventData ?? string.Empty);
break;
}
}
private void HandleIncomingEvents(EventReceive @event)
{
RunSpeedTestAndUploadResults().GetAwaiter().GetResult();
}
