internal static Task SendRequestChannel(this RSocket socket, int streamId, ReadOnlySequence <byte> data, ReadOnlySequence <byte> metadata = default, Int32 initialRequest = 0, bool follows = false, bool complete = false)
{
return(socket.OutputSync(output =>
{
return new RSocketProtocol.RequestChannel(streamId, data, metadata, initialRequest, follows, complete).WriteFlush(output, data, metadata);
}));
}
internal static Task SendPayload(this RSocket socket, int streamId, ReadOnlySequence <byte> data = default, ReadOnlySequence <byte> metadata = default, bool follows = false, bool complete = false, bool next = false)
{
return(socket.OutputSync(output =>
{
return new RSocketProtocol.Payload(streamId, data, metadata, follows: follows, complete: complete, next: next).WriteFlush(output, data, metadata);
}));
}
internal static Task SendSetup(this RSocket socket, TimeSpan keepalive, TimeSpan lifetime, string metadataMimeType = null, string dataMimeType = null, byte[] resumeToken = default, ReadOnlySequence <byte> data = default, ReadOnlySequence <byte> metadata = default)
{
return(socket.OutputSync(output =>
{
return new RSocketProtocol.Setup(keepalive, lifetime, metadataMimeType: metadataMimeType, dataMimeType: dataMimeType, resumeToken: resumeToken, data: data, metadata: metadata).WriteFlush(output, data: data, metadata: metadata);
}));
}
public static async Task <string> RequestResponse(this RSocket socket, string data, string metadata = default)
{
var payload = await socket.RequestResponse(Helpers.StringToByteSequence(data), Helpers.StringToByteSequence(metadata));
string str = Encoding.UTF8.GetString(payload.Data.ToArray());
return(str);
}
internal static Task SendKeepAlive(this RSocket socket, int lastReceivedPosition, bool respond)
{
return(socket.OutputSync(output =>
{
RSocketProtocol.KeepAlive keepAlive = new RSocketProtocol.KeepAlive(lastReceivedPosition, respond);
return keepAlive.WriteFlush(output);
}));
}
internal static Task SendRequestN(this RSocket socket, int streamId, int n)
{
return(socket.OutputSync(output =>
{
var requestne = new RequestN(streamId, default(ReadOnlySequence <byte>), initialRequest: n);
return requestne.WriteFlush(output);
}));
}
internal static Task SendCancel(this RSocket socket, int streamId = 0)
{
return(socket.OutputSync(output =>
{
var cancel = new Cancel(streamId);
return cancel.WriteFlush(output);
}));
}
internal static Task SendError(this RSocket socket, int streamId, ErrorCodes errorCode, string errorText, bool throwIfExceptionOccurred = true)
{
var errorData = default(ReadOnlySequence <byte>);
if (errorText != null)
{
errorData = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(errorText));
}
return(SendError(socket, streamId, errorCode, errorData, throwIfExceptionOccurred));
}
internal static Task SendError(this RSocket socket, int streamId, ErrorCodes errorCode, ReadOnlySequence <byte> errorData, bool throwIfExceptionOccurred = true)
{
try
{
return(socket.OutputSync(output =>
{
return new RSocketProtocol.Error(errorCode, streamId, errorData).WriteFlush(output, errorData);
}));
}
catch
{
if (throwIfExceptionOccurred)
{
throw;
}
return(Task.CompletedTask);
}
}
internal static async Task OutputSync(this RSocket socket, Func <System.IO.Pipelines.PipeWriter, Task> func)
{
//lock (socket.Transport.Output)
//{
// func(socket.Transport.Output).Wait(); //There is a deadlock hazard here.
// return;
//}
await socket.OutputSyncLock.WaitAsync();
try
{
/* ps: PipeWriter is not a thread-safe object. */
await func(socket.Transport.Output);
}
finally
{
socket.OutputSyncLock.Release();
}
}
public EchoServiceServer(RSocket.RSocket socket)
{
RSocketService.Register(socket, this);
}
public RequestResponseRequesterIncomingStream(RSocket socket, Func <int, Task> channelEstablisher) : base(socket, channelEstablisher)
{
}
public RequestFireAndForgetRequesterIncomingStream(RSocket socket, Func <int, Task> channelEstablisher) : base(socket, channelEstablisher)
{
}
public OutputPublisher(RSocket.RSocket socket, int maxOutputs, int errorTrigger = int.MaxValue) : base(socket)
{
this._maxOutputs = maxOutputs;
this._errorTrigger = errorTrigger;
}
public static IAsyncEnumerable <string> RequestChannel(this RSocket socket, IAsyncEnumerable <string> inputs, string data = default, string metadata = default)
{
IObservable <Payload> source = inputs.Select(a => new Payload(Helpers.StringToByteSequence(a))).ToObservable();
return(socket.RequestChannel(Helpers.StringToByteSequence(data), Helpers.StringToByteSequence(metadata), source, int.MaxValue).ToAsyncEnumerable().Select(a => Encoding.UTF8.GetString(a.Data.ToArray())));
}
public OutputPublisher(RSocket.RSocket socket) : base(socket)
{
}
public RequestStreamRequesterIncomingStream(RSocket socket, Func <int, Task> channelEstablisher) : base(socket, new Publisher <Payload>(), channelEstablisher)
{
}
public RequesterIncomingStream(RSocket socket, IObservable <Payload> outputs, Func <int, Task> channelEstablisher)
{
this.Socket = socket;
this._outputs = outputs;
this._channelEstablisher = channelEstablisher;
}
public static async Task RequestFireAndForget(this RSocket socket, string data, string metadata = default)
{
await socket.RequestFireAndForget(Helpers.StringToByteSequence(data), Helpers.StringToByteSequence(metadata));
}
public Publisher(RSocket.RSocket socket)
{
this.Socket = socket;
}
public static IAsyncEnumerable <string> RequestStream(this RSocket socket, string data, string metadata = default)
{
var payloads = socket.RequestStream(Helpers.StringToByteSequence(data), Helpers.StringToByteSequence(metadata), int.MaxValue);
return(payloads.ToAsyncEnumerable().Select(a => Encoding.UTF8.GetString(a.Data.ToArray())));
}
public OutputSubscription(RSocket.RSocket socket, IObserver <Payload> observer, int maxResponses = int.MaxValue, int errorTrigger = int.MaxValue) : base(observer)
{
this.Socket = socket;
this._maxResponses = maxResponses;
this._errorTrigger = errorTrigger;
}
public MyEchoServer(RSocket.RSocket socket) : base(socket)
{
}
