private static ReadResp.Types.ReadEvent.Types.RecordedEvent ConvertToRecordedEvent(
ReadReq.Types.Options.Types.UUIDOption uuidOption, EventRecord e, long?commitPosition,
long?preparePosition)
{
if (e == null)
{
return(null);
}
var position = Position.FromInt64(commitPosition ?? -1, preparePosition ?? -1);
return(new ReadResp.Types.ReadEvent.Types.RecordedEvent {
Id = uuidOption.ContentCase switch {
ReadReq.Types.Options.Types.UUIDOption.ContentOneofCase.String => new UUID {
String = e.EventId.ToString()
},
_ => Uuid.FromGuid(e.EventId).ToDto()
},
private ClusterInfo ToGrpcClusterInfo(Core.Cluster.ClientClusterInfo cluster)
{
var members = Array.ConvertAll(cluster.Members, x => new MemberInfo {
InstanceId = Uuid.FromGuid(x.InstanceId).ToDto(),
TimeStamp = x.TimeStamp.ToTicksSinceEpoch(),
State = (MemberInfo.Types.VNodeState)x.State,
IsAlive = x.IsAlive,
HttpEndPoint = new EndPoint {
Address = x.HttpEndPointIp,
Port = (uint)x.HttpEndPointPort
}
}).ToArray();
var info = new ClusterInfo();
info.Members.AddRange(members);
return(info);
}
private async Task Receive(ChannelWriter <BatchAppendResp> writer, ClaimsPrincipal user, bool requiresLeader,
CancellationToken cancellationToken)
{
var pendingWrites = new ConcurrentDictionary <Guid, ClientWriteRequest>();
try {
await foreach (var request in _requestStream.ReadAllAsync(cancellationToken))
{
try {
var correlationId = Uuid.FromDto(request.CorrelationId).ToGuid();
if (request.Options != null)
{
TimeSpan timeout = Min(GetRequestedTimeout(request.Options), _writeTimeout);
if (!await _authorizationProvider.CheckAccessAsync(user, WriteOperation.WithParameter(
Plugins.Authorization.Operations.Streams.Parameters.StreamId(
request.Options.StreamIdentifier)), cancellationToken).ConfigureAwait(false))
{
await writer.WriteAsync(new BatchAppendResp {
CorrelationId = request.CorrelationId,
StreamIdentifier = request.Options.StreamIdentifier,
Error = Status.AccessDenied
}, cancellationToken).ConfigureAwait(false);
continue;
}
if (request.Options.StreamIdentifier == null)
{
await writer.WriteAsync(new BatchAppendResp {
CorrelationId = request.CorrelationId,
StreamIdentifier = request.Options.StreamIdentifier,
Error = Status.BadRequest(
$"Required field {nameof(request.Options.StreamIdentifier)} not set.")
}, cancellationToken).ConfigureAwait(false);
continue;
}
if (Max(timeout, TimeSpan.Zero) == TimeSpan.Zero)
{
await writer.WriteAsync(new BatchAppendResp {
CorrelationId = request.CorrelationId,
StreamIdentifier = request.Options.StreamIdentifier,
Error = Status.Timeout
}, cancellationToken).ConfigureAwait(false);
continue;
}
pendingWrites.AddOrUpdate(correlationId,
c => FromOptions(c, request.Options, timeout, cancellationToken),
(_, writeRequest) => writeRequest);
}
if (!pendingWrites.TryGetValue(correlationId, out var clientWriteRequest))
{
continue;
}
clientWriteRequest.AddEvents(request.ProposedMessages.Select(FromProposedMessage));
if (clientWriteRequest.Size > _maxAppendSize)
{
pendingWrites.TryRemove(correlationId, out _);
await writer.WriteAsync(new BatchAppendResp {
CorrelationId = request.CorrelationId,
StreamIdentifier = clientWriteRequest.StreamId,
Error = Status.MaximumAppendSizeExceeded((uint)_maxAppendSize)
}, cancellationToken).ConfigureAwait(false);
}
if (!request.IsFinal)
{
continue;
}
if (!pendingWrites.TryRemove(correlationId, out _))
{
continue;
}
Interlocked.Increment(ref _pending);
_publisher.Publish(ToInternalMessage(clientWriteRequest, new CallbackEnvelope(message => {
try {
writer.TryWrite(ConvertMessage(message));
} catch (Exception ex) {
writer.TryComplete(ex);
}
}), requiresLeader, user, cancellationToken));
BatchAppendResp ConvertMessage(Message message)
{
var batchAppendResp = message switch {
ClientMessage.NotHandled notHandled => new BatchAppendResp {
Error = new Status {
Details = Any.Pack(new Empty()),
Message = (notHandled.Reason, notHandled.AdditionalInfo) switch {
(NotHandledReason.NotReady, _) => "Server Is Not Ready",
(NotHandledReason.TooBusy, _) => "Server Is Busy",
(NotHandledReason.NotLeader or NotHandledReason.IsReadOnly,
LeaderInfo leaderInfo) =>
throw RpcExceptions.LeaderInfo(leaderInfo.HttpAddress,
leaderInfo.HttpPort),
(NotHandledReason.NotLeader or NotHandledReason.IsReadOnly, _) =>
"No leader info available in response",
_ => $"Unknown {nameof(NotHandledReason)} ({(int)notHandled.Reason})"
}
}
},
ClientMessage.WriteEventsCompleted completed => completed.Result switch {
OperationResult.Success => new BatchAppendResp {
Success = BatchAppendResp.Types.Success.Completed(completed.CommitPosition,
completed.PreparePosition, completed.LastEventNumber),
},
OperationResult.WrongExpectedVersion => new BatchAppendResp {
Error = Status.WrongExpectedVersion(
StreamRevision.FromInt64(completed.CurrentVersion),
clientWriteRequest.ExpectedVersion)
},
OperationResult.AccessDenied => new BatchAppendResp
{
Error = Status.AccessDenied
},
OperationResult.StreamDeleted => new BatchAppendResp {
Error = Status.StreamDeleted(clientWriteRequest.StreamId)
},
OperationResult.CommitTimeout or
OperationResult.ForwardTimeout or
OperationResult.PrepareTimeout => new BatchAppendResp
{
Error = Status.Timeout
},
_ => new BatchAppendResp {
Error = Status.Unknown
}
},
_ => new BatchAppendResp {
Error = new Status {
Details = Any.Pack(new Empty()),
Message =
$"Envelope callback expected either {nameof(ClientMessage.WriteEventsCompleted)} or {nameof(ClientMessage.NotHandled)}, received {message.GetType().Name} instead"
}
}
};
batchAppendResp.CorrelationId = Uuid.FromGuid(correlationId).ToDto();
batchAppendResp.StreamIdentifier = new StreamIdentifier {
StreamName = ByteString.CopyFromUtf8(clientWriteRequest.StreamId)
};
return(batchAppendResp);
}
} catch (Exception ex) {
await writer.WriteAsync(new BatchAppendResp {
CorrelationId = request.CorrelationId,
StreamIdentifier = request.Options.StreamIdentifier,
Error = Status.BadRequest(ex.Message)
}, cancellationToken).ConfigureAwait(false);
}
}