public TcpPipeChannel(Socket socket, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
: base(pipelineFilter, options)
{
_socket = socket;
RemoteEndPoint = socket.RemoteEndPoint;
LocalEndPoint = socket.LocalEndPoint;
}
private void ReaderBuffer(ReadOnlySequence <byte> buffer, out SequencePosition consumed, out SequencePosition examined)
{
consumed = buffer.Start;
examined = buffer.End;
var seqReader = new SequenceReader <byte>(buffer);
var currentPipelineFilter = _pipelineFilter;
var packageInfo = currentPipelineFilter.Filter(ref seqReader);
if (currentPipelineFilter.NextFilter != null)
{
_pipelineFilter = currentPipelineFilter.NextFilter;
}
// continue receive...
if (packageInfo == null)
{
return;
}
currentPipelineFilter.Reset();
// already get a package
OnPackageReceived(packageInfo);
if (seqReader.End) // no more data
{
consumed = buffer.End;
}
else
{
examined = consumed = seqReader.Position;
}
}
protected PipeChannel(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options, ILogger logger)
{
_pipelineFilter = pipelineFilter;
Options = options;
Logger = logger;
Output = new Pipe();
}
public WebSocketPackage Filter(ref SequenceReader <byte> reader)
{
var terminatorSpan = _headerTerminator.Span;
if (!reader.TryReadToAny(out ReadOnlySequence <byte> pack, terminatorSpan, advancePastDelimiter: false))
{
return(null);
}
for (var i = 0; i < terminatorSpan.Length - 1; i++)
{
if (!reader.IsNext(terminatorSpan, advancePast: true))
{
return(null);
}
}
var header = ParseHttpHeaderItems(pack);
var package = new WebSocketPackage
{
HttpHeader = header,
OpCode = OpCode.Handshake
};
NextFilter = new WebSocketDataPipelineFilter();
return(package);
}
/// <summary>
/// 初始化Udp管道
/// </summary>
/// <param name="socket">Socket通道</param>
/// <param name="pipelineFilter">管道筛选器</param>
/// <param name="options">选项</param>
/// <param name="remoteEndPoint">远程网络标识</param>
/// <param name="sessionIdentifier">Session标识符</param>
public UdpPipeChannel(Socket socket, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options, IPEndPoint remoteEndPoint, string sessionIdentifier)
: base(pipelineFilter, options)
{
_socket = socket;
_remoteEndPoint = remoteEndPoint;
SessionIdentifier = sessionIdentifier;
}
protected PipeChannel(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
{
_pipelineFilter = pipelineFilter;
Options = options;
Logger = options.Logger;
Out = options.Out ?? new Pipe();
In = options.In ?? new Pipe();
}
public UdpPipeChannel(Socket socket, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options, IPEndPoint remoteEndPoint, string sessionIdentifier)
: base(pipelineFilter, options)
{
_socket = socket;
_enableSendingPipe = "true".Equals(options.Values?["enableSendingPipe"], StringComparison.OrdinalIgnoreCase);
RemoteEndPoint = remoteEndPoint;
SessionIdentifier = sessionIdentifier;
}
protected PipeChannel(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
{
_pipelineFilter = pipelineFilter;
_packageTaskSource = new ManualResetValueTaskSourceCore <TPackageInfo>();
Options = options;
Logger = options.Logger;
Out = options.Out ?? new Pipe();
In = options.In ?? new Pipe();
}
protected PipeChannel(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
{
_oriPipelineFilter = pipelineFilter;
_pipelineFilter = pipelineFilter;
_packagePipe = new DefaultObjectPipe <TPackageInfo>();
Options = options;
Logger = options.Logger;
Out = options.Out ?? new Pipe();
In = options.In ?? new Pipe();
}
private bool ReaderBuffer(ReadOnlySequence <byte> buffer, out SequencePosition consumed, out SequencePosition examined)
{
consumed = buffer.Start;
examined = buffer.End;
var maxPackageLength = Options.MaxPackageLength;
var seqReader = new SequenceReader <byte>(buffer);
while (true)
{
var currentPipelineFilter = _pipelineFilter;
var packageInfo = currentPipelineFilter.Filter(ref seqReader);
if (currentPipelineFilter.NextFilter != null)
{
_pipelineFilter = currentPipelineFilter.NextFilter;
}
var pos = seqReader.Position.GetInteger();
if (maxPackageLength > 0 && pos > maxPackageLength)
{
Logger.LogError($"Package cannot be larger than {maxPackageLength}.");
// close the the connection directly
Close();
_packageTaskSource.SetResult(null);
return(false);
}
// continue receive...
if (packageInfo == null)
{
return(true);
}
currentPipelineFilter.Reset();
_packageTaskSource.SetResult(packageInfo);
_packageTaskSource.Reset();
if (seqReader.End) // no more data
{
consumed = buffer.End;
break;
}
else
{
examined = consumed = seqReader.Position;
}
}
return(true);
}
public override async Task ProcessRequest()
{
var input = Pipe.Input;
var currentPipelineFilter = _pipelineFilter;
while (true)
{
var result = await input.ReadAsync();
var buffer = result.Buffer;
try
{
if (result.IsCompleted)
{
OnClosed();
break;
}
while (true)
{
var packageInfo = currentPipelineFilter.Filter(ref buffer);
if (currentPipelineFilter.NextFilter != null)
{
_pipelineFilter = currentPipelineFilter = currentPipelineFilter.NextFilter;
}
// continue receive...
if (packageInfo == null)
{
break;
}
// already get a package
OnPackageReceived(packageInfo);
if (buffer.Length == 0) // no more data
{
break;
}
}
}
finally
{
input.AdvanceTo(buffer.Start, buffer.End);
}
}
await Task.CompletedTask;
}
/// <summary>
/// Initializes a new instance of the <see cref="LiveCharts_co_uk_PriceReceiver"/> class.
/// </summary>
/// <param name="scraper">The scraper.</param>
/// <param name="stockMarket">The stock market.</param>
/// <param name="filter">The filter.</param>
/// <param name="timePeriodLengthSecs">The time period length secs.</param>
public LiveCharts_co_uk_PriceReceiver(IScraper scraper, IStockMarket stockMarket, IPipelineFilter filter, int timePeriodLengthSecs)
: this()
{
Condition.Requires(scraper).IsNotNull();
Condition.Requires(stockMarket).IsNotNull();
Condition.Requires(timePeriodLengthSecs).IsGreaterThan(0);
this._scraper = scraper;
this._stockMarket = stockMarket;
this._filter = filter;
this._timePeriodLengthSecs = timePeriodLengthSecs;
}
protected async Task ReadPipeAsync(PipeReader reader)
{
var currentPipelineFilter = _pipelineFilter;
while (true)
{
var result = await reader.ReadAsync();
var buffer = result.Buffer;
try
{
if (result.IsCompleted)
{
OnClosed();
break;
}
while (true)
{
var packageInfo = currentPipelineFilter.Filter(ref buffer);
if (currentPipelineFilter.NextFilter != null)
{
_pipelineFilter = currentPipelineFilter = currentPipelineFilter.NextFilter;
}
// continue receive...
if (packageInfo == null)
{
break;
}
// already get a package
OnPackageReceived(packageInfo);
if (buffer.Length == 0) // no more data
{
break;
}
}
}
finally
{
reader.AdvanceTo(buffer.Start, buffer.End);
}
}
reader.Complete();
}
/// <summary>
/// 创建通道
/// </summary>
/// <typeparam name="TReceivePackage">接收包</typeparam>
/// <param name="pipelineFilter">内置命令行</param>
/// <param name="channelOptions">通道设置</param>
/// <returns>Stream/Tcp通道</returns>
public IChannel <TReceivePackage> CreateChannel <TReceivePackage>(IPipelineFilter <TReceivePackage> pipelineFilter, ChannelOptions channelOptions)
where TReceivePackage : class
{
var stream = this.Stream;
var socket = this.Socket;
if (stream != null)
{
return(new StreamPipeChannel <TReceivePackage>(stream, socket.RemoteEndPoint, socket.LocalEndPoint, pipelineFilter, channelOptions));
}
else
{
return(new TcpPipeChannel <TReceivePackage>(socket, pipelineFilter, channelOptions));
}
}
public override async Task ProcessRequest()
{
var input = PipeConnection.Input;
//var consumed = new ReadCursor();
//var examined = new ReadCursor();
var currentPipelineFilter = _pipelineFilter;
while (true)
{
var result = await input.ReadAsync();
if (result.IsCompleted)
{
OnClosed();
break;
}
var buffer = result.Buffer;
while (true)
{
var packageInfo = currentPipelineFilter.Filter(ref buffer);
if (currentPipelineFilter.NextFilter != null)
{
_pipelineFilter = currentPipelineFilter = currentPipelineFilter.NextFilter;
}
// continue receive...
if (packageInfo == null)
{
break;
}
// already get a package
OnPackageReceived(packageInfo);
if (buffer.Length == 0) // no more data
{
break;
}
}
}
await Task.CompletedTask;
}
public WebSocketPackage Filter(ref SequenceReader <byte> reader)
{
var terminatorSpan = _headerTerminator.Span;
if (!reader.TryReadTo(out ReadOnlySequence <byte> pack, terminatorSpan, advancePastDelimiter: false))
{
return(null);
}
reader.Advance(terminatorSpan.Length);
var package = ParseHandshake(ref pack);
NextFilter = new WebSocketDataPipelineFilter(package.HttpHeader);
return(package);
}
protected PipeChannel(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
{
_pipelineFilter = pipelineFilter;
if (!options.ReadAsDemand)
{
_packagePipe = new DefaultObjectPipe <TPackageInfo>();
}
else
{
_packagePipe = new DefaultObjectPipeWithSupplyControl <TPackageInfo>();
}
Options = options;
Logger = options.Logger;
Out = options.Out ?? new Pipe();
In = options.In ?? new Pipe();
}
private bool ReaderBuffer(ref ReadOnlySequence <byte> buffer, out SequencePosition consumed, out SequencePosition examined)
{
consumed = buffer.Start;
examined = buffer.End;
var bytesConsumedTotal = 0L;
var maxPackageLength = Options.MaxPackageLength;
var seqReader = new SequenceReader <byte>(buffer);
while (true)
{
var currentPipelineFilter = _pipelineFilter;
var packageInfo = currentPipelineFilter.Filter(ref seqReader);
var nextFilter = currentPipelineFilter.NextFilter;
if (nextFilter != null)
{
nextFilter.Context = currentPipelineFilter.Context; // pass through the context
_pipelineFilter = nextFilter;
}
var bytesConsumed = seqReader.Consumed;
bytesConsumedTotal += bytesConsumed;
var len = bytesConsumed;
// nothing has been consumed, need more data
if (len == 0)
{
len = seqReader.Length;
}
if (maxPackageLength > 0 && len > maxPackageLength)
{
Logger.LogError($"Package cannot be larger than {maxPackageLength}.");
// close the the connection directly
Close();
return(false);
}
// continue receive...
if (packageInfo == null)
{
consumed = buffer.GetPosition(bytesConsumedTotal);
return(true);
}
currentPipelineFilter.Reset();
_packagePipe.Write(packageInfo);
if (seqReader.End) // no more data
{
examined = consumed = buffer.End;
return(true);
}
seqReader = new SequenceReader <byte>(seqReader.Sequence.Slice(bytesConsumed));
}
}
public EasyClient(IPipelineFilter <TPackage> pipelineFilter, Func <TPackage, Task> handler, IPackageEncoder <TPackage> packageEncoder = null, ILogger logger = null)
: base(pipelineFilter, handler, packageEncoder, logger)
{
}
public override IEasyClient <TPackageInfo> ConfigureEasyClient <TPackageInfo>(IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options) where TPackageInfo : class
{
var client = new EasyClient <TPackageInfo>(pipelineFilter, options);
client.Security = new SecurityOptions
{
TargetHost = "supersocket",
EnabledSslProtocols = GetClientEnabledSslProtocols(),
RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true
};
return(client);
}
/// <summary>
/// Sets the filter for the pipeline, where the user can add/remove or change handlers.
/// </summary>
public ChannelClientConfiguration SetPipelineFilter(IPipelineFilter pipelineFilter)
{
PipelineFilter = pipelineFilter;
return this;
}
public TcpPipeChannel(Socket socket, IPipelineFilter pipelineFilter)
: base(pipelineFilter)
{
_socket = socket;
}
/// <summary>
/// Sets the filter for the pipeline, where the user can add, remove or change filters.
/// </summary>
/// <returns></returns>
public ChannelServerConfiguration SetPipelineFilter(IPipelineFilter pipelineFilter)
{
_pipelineFilter = pipelineFilter;
return this;
}
public StreamPipeChannel(Stream stream, EndPoint remoteEndPoint, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
: this(stream, remoteEndPoint, null, pipelineFilter, options)
{
}
/// <summary>
/// Sets the filter for the pipeline, where the user can add/remove or change handlers.
/// </summary>
public ChannelClientConfiguration SetPipelineFilter(IPipelineFilter pipelineFilter)
{
PipelineFilter = pipelineFilter;
return(this);
}
public SecureEasyClient(IPipelineFilter <TReceivePackage> pipelineFilter, ChannelOptions options)
: base(pipelineFilter, options)
{
}
public EasyClient(IPipelineFilter <TPackage> pipelineFilter, IPackageEncoder <TSendPackage> packageEncoder, ChannelOptions options)
: base(pipelineFilter, options)
{
_packageEncoder = packageEncoder;
}
public EasyClient(IPipelineFilter <TPackage> pipelineFilter, IPackageEncoder <TSendPackage> packageEncoder = null, ILogger logger = null)
: base(pipelineFilter, logger)
{
_packageEncoder = packageEncoder;
}
public EasyClient(IPipelineFilter <TPackage> pipelineFilter, IPackageEncoder <TSendPackage> packageEncoder, ILogger logger = null)
: this(pipelineFilter, packageEncoder, new ChannelOptions {
Logger = logger
})
{
}
public StreamPipeChannel(Stream stream, EndPoint remoteEndPoint, EndPoint localEndPoint, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
: base(pipelineFilter, options)
{
_stream = stream;
RemoteEndPoint = remoteEndPoint;
LocalEndPoint = localEndPoint;
StartTasks();
}
public SerialIOPipeChannel(SerialPort serialPort, IPipelineFilter <TPackageInfo> pipelineFilter, ChannelOptions options)
: base(pipelineFilter, options)
{
_serialPort = serialPort;
}
public SecureEasyClient(IPipelineFilter <TReceivePackage> pipelineFilter, ILogger logger)
: this(pipelineFilter, new ChannelOptions {
Logger = logger
})
{
}
