public WebSocketClientHandler(WSClient client, WebSocketClientHandshaker handshaker, ConnectionListener <MQMessage> listener)
{
this.client = client;
this.handshaker = handshaker;
this.listener = listener;
this.completionSource = new TaskCompletionSource();
}
public WebSocketClientHandler(WebSocketClient client, WebSocketClientHandshaker shaker)
{
_client = client;
handshaker = shaker;
completionSource = new TaskCompletionSource();
}
public WebSocketClientHandler(WebSocketClientHandshaker handshaker, ResponseWaits _waits, AbsClientConnect _clientConnect)
{
this.handshaker = handshaker;
clientConnect = _clientConnect as WebSocketClientConnect;
this.completionSource = new TaskCompletionSource();
waits = _waits;
}
private static EmbeddedChannel CreateClientChannel(WebSocketClientHandshaker handshaker, IChannelHandler handler)
{
return(new EmbeddedChannel(
new HttpClientCodec(),
new HttpObjectAggregator(8192),
// Note that we're switching off close frames handling on purpose to test forced close on timeout.
new WebSocketClientProtocolHandler(handshaker, false, false),
handler));
}
public WebSocketClientHandler(IWebSocketClient client,
WebSocketClientHandshaker handshaker)
{
_client = client;
_logger = client.LoggerFactory.CreateLogger <WebSocketClientHandler>();
_handshaker = handshaker;
_completionSource = new TaskCompletionSource();
}
public void UpgradeUrl()
{
var uri = new Uri("ws://localhost:9999/path%20with%20ws");
WebSocketClientHandshaker handshaker = this.NewHandshaker(uri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/path%20with%20ws", request.Uri);
}
finally
{
request.Release();
}
}
public void UpgradeUrlWithoutPathWithQuery()
{
Uri uri = new Uri("ws://localhost:9999?a=b%20c");
WebSocketClientHandshaker handshaker = NewHandshaker(uri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/?a=b%20c", request.Uri);
}
finally
{
request.Release();
}
}
public void AbsoluteUpgradeUrlWithQuery()
{
var uri = new Uri("ws://localhost:9999/path%20with%20ws?a=b%20c");
WebSocketClientHandshaker handshaker = NewHandshaker(uri, null, null, true);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("ws://localhost:9999/path%20with%20ws?a=b%20c", request.Uri);
}
finally
{
request.Release();
}
}
public void SetOriginFromCustomHeaders()
{
HttpHeaders customHeaders = new DefaultHttpHeaders().Set(GetOriginHeaderName(), "http://example.com");
WebSocketClientHandshaker handshaker = NewHandshaker(new Uri("ws://server.example.com/chat"), null,
customHeaders, false);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("http://example.com", request.Headers.Get(GetOriginHeaderName(), null));
}
finally
{
request.Release();
}
}
protected void HeaderDefaultHttp(string uri, AsciiString header, string expectedValue)
{
Assert.True(Uri.TryCreate(uri, UriKind.RelativeOrAbsolute, out Uri originalUri));
WebSocketClientHandshaker handshaker = this.NewHandshaker(originalUri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.True(request.Headers.TryGet(header, out ICharSequence value));
Assert.Equal(expectedValue, value.ToString(), true);
}
finally
{
request.Release();
}
}
public async Task StartAsync <T>() where T : IWebSocketClientHandler
{
if (!(Config is DotNettyClientConfig webSocketClientConfig))
{
throw new MateralWebSocketClientException("Config类型必须派生于DotNettyClientConfig");
}
WebSocketClientHandshaker webSocketClientHandshaker = WebSocketClientHandshakerFactory.NewHandshaker(webSocketClientConfig.UriBuilder.Uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders());
var handler = ConvertManager.GetDefaultObject <T>(webSocketClientHandshaker);
if (!(handler is DotNettyClientHandler clientHandler))
{
throw new MateralWebSocketClientException("Handler类型必须派生于DotNettyClientHandler");
}
_clientHandler = clientHandler;
_clientHandler.SetClient(this);
await StartAsync();
}
public void HostHeaderPreserved()
{
Uri uri = new Uri("ws://localhost:9999");
WebSocketClientHandshaker handshaker = NewHandshaker(uri, null,
new DefaultHttpHeaders().Set(HttpHeaderNames.Host, "test.netty.io"), false);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/", request.Uri);
Assert.Equal("test.netty.io", request.Headers.Get(HttpHeaderNames.Host, null));
}
finally
{
request.Release();
}
}
public async Task RunAsync()
{
OnSubMessage?.Invoke("连接服务中......", "重要");
//第一步：创建ServerBootstrap实例
var bootstrap = new Bootstrap();
//第二步：绑定事件组
workGroup = new MultithreadEventLoopGroup();
bootstrap.Group(workGroup);
//第三部：绑定通道
bootstrap.Channel <TcpSocketChannel>();
//第四步：配置处理器
bootstrap.Option(ChannelOption.TcpNodelay, true);
var builder = new UriBuilder
{
Scheme = _clientConfig.IsWss ? "wss" : "ws",
Host = _clientConfig.Host,
Port = _clientConfig.Port,
Path = _clientConfig.Path
};
WebSocketClientHandshaker clientHandshaker = WebSocketClientHandshakerFactory.NewHandshaker(builder.Uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders());
var handler = new ClientChannelHandler(clientHandshaker);
bootstrap.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast("tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), new ClientTlsSettings(null)));
pipeline.AddLast(
new HttpClientCodec(),
new HttpObjectAggregator(8192),
WebSocketClientCompressionHandler.Instance,
handler);
}));
Channel = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(_clientConfig.Host), _clientConfig.Port));
await handler.HandshakeCompletion;
}
public void ClientHandshakerForceClose()
{
WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.NewHandshaker(
new Uri("ws://localhost:1234/test"), WebSocketVersion.V13, null, true,
EmptyHttpHeaders.Default, int.MaxValue, true, false, 20);
EmbeddedChannel serverChannel = CreateServerChannel(
new CloseNoOpServerProtocolHandler(this, "/test"),
new ServerHandshakeForceCloseHander(this));
EmbeddedChannel clientChannel = CreateClientChannel(handshaker, new ClientHandshakeForceCloseHander(this, handshaker));
// Transfer the handshake from the client to the server
TransferAllDataWithMerge(clientChannel, serverChannel);
// Transfer the handshake from the server to client
TransferAllDataWithMerge(serverChannel, clientChannel);
// Transfer closing handshake
TransferAllDataWithMerge(clientChannel, serverChannel);
Assert.True(_serverReceivedCloseHandshake);
// Should not be closed yet as we disabled closing the connection on the server
Assert.False(_clientForceClosed);
while (!_clientForceClosed)
{
Thread.Sleep(10);
// We need to run all pending tasks as the force close timeout is scheduled on the EventLoop.
clientChannel.RunPendingTasks();
}
// clientForceClosed would be set to TRUE after any close,
// so check here that force close timeout was actually fired
Assert.True(handshaker.IsForceCloseComplete);
// Both should be empty
Assert.False(serverChannel.FinishAndReleaseAll());
Assert.False(clientChannel.FinishAndReleaseAll());
}
protected DotNettyClientHandler(WebSocketClientHandshaker handshaker)
{
Handshaker = handshaker;
CompletionSource = new TaskCompletionSource();
}
public Boolean Init(ConnectionListener <MQMessage> listener)
{
if (channel == null)
{
bootstrap = new Bootstrap();
loopGroup = new MultithreadEventLoopGroup(workerThreads);
bootstrap.Group(loopGroup);
bootstrap.Channel <TcpSocketChannel>();
bootstrap.Option(ChannelOption.TcpNodelay, true);
bootstrap.Option(ChannelOption.SoKeepalive, true);
X509Certificate2 cert = null;
if (certificate != null && certificate.Length > 0)
{
cert = CertificatesHelper.load(certificate, certificatePassword);
}
WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.NewHandshaker(this.getUri(), WebSocketVersion.V13, null, false, EmptyHttpHeaders.Default, 1280000);
WebSocketClientHandler handler = new WebSocketClientHandler(this, handshaker, listener);
bootstrap.Handler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (isSecured)
{
if (cert != null)
{
pipeline.AddLast("ssl", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true, (sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers) => cert), new ClientTlsSettings(address.Host, new List <X509Certificate>()
{
cert
})));
}
else
{
pipeline.AddLast("ssl", TlsHandler.Client(address.Host));
}
}
pipeline.AddLast("http - codec", new HttpClientCodec());
pipeline.AddLast("aggregator", new HttpObjectAggregator(65536));
pipeline.AddLast("handler", handler);
pipeline.AddLast(new ExceptionHandler());
}));
bootstrap.RemoteAddress(address);
try
{
Task <IChannel> task = bootstrap.ConnectAsync();
task.GetAwaiter().OnCompleted(() =>
{
try
{
channel = task.Result;
}
catch (Exception)
{
listener.ConnectFailed();
return;
}
if (channel != null)
{
listener.Connected();
}
else
{
listener.ConnectFailed();
}
});
}
catch (Exception)
{
return(false);
}
}
return(true);
}
public BilibiliLiveHandler(WebSocketClientHandshaker handshaker, BilibiliLiveNetty bilibiliLiveNetty)
{
this.handshaker = handshaker;
completionSource = new TaskCompletionSource();
this.bilibiliLiveNetty = bilibiliLiveNetty;
}
public Handshaker(WebSocketClientHandshaker clientHandshaker, IChannel channel, TaskCompletionSource completion)
{
this.clientHandshaker = clientHandshaker;
this.channel = channel;
this.completion = completion;
}
public ClientHandshakeForceCloseHander(WebSocketHandshakeHandOverTest owner, WebSocketClientHandshaker handshaker)
{
_owner = owner;
_handshaker = handshaker;
}
public WebSocketClientHandler(WebSocketClientHandshaker handshaker)
{
_handshaker = handshaker;
}
public Handshaker(WebSocketClientHandshaker clientHandshaker, IChannel channel, IPromise completion)
{
_clientHandshaker = clientHandshaker;
_channel = channel;
_completion = completion;
}
public WebSocketClientHandler(WebSocketClientHandshaker handshaker)
{
this.handshaker = handshaker;
this.completionSource = new TaskCompletionSource();
}
void TestHttpResponseAndFrameInSameBuffer(bool codec)
{
string url = "ws://localhost:9999/ws";
WebSocketClientHandshaker shaker = this.NewHandshaker(new Uri(url));
var handshaker = new Handshaker(shaker);
// use randomBytes helper from utils to check that it functions properly
byte[] data = WebSocketUtil.RandomBytes(24);
// Create a EmbeddedChannel which we will use to encode a BinaryWebsocketFrame to bytes and so use these
// to test the actual handshaker.
var factory = new WebSocketServerHandshakerFactory(url, null, false);
IFullHttpRequest request = shaker.NewHandshakeRequest();
WebSocketServerHandshaker socketServerHandshaker = factory.NewHandshaker(request);
request.Release();
var websocketChannel = new EmbeddedChannel(socketServerHandshaker.NewWebSocketEncoder(),
socketServerHandshaker.NewWebsocketDecoder());
Assert.True(websocketChannel.WriteOutbound(new BinaryWebSocketFrame(Unpooled.WrappedBuffer(data))));
byte[] bytes = Encoding.ASCII.GetBytes("HTTP/1.1 101 Switching Protocols\r\nContent-Length: 0\r\n\r\n");
CompositeByteBuffer compositeByteBuf = Unpooled.CompositeBuffer();
compositeByteBuf.AddComponent(true, Unpooled.WrappedBuffer(bytes));
for (; ;)
{
var frameBytes = websocketChannel.ReadOutbound <IByteBuffer>();
if (frameBytes == null)
{
break;
}
compositeByteBuf.AddComponent(true, frameBytes);
}
var ch = new EmbeddedChannel(new HttpObjectAggregator(int.MaxValue), new Handler(handshaker));
if (codec)
{
ch.Pipeline.AddFirst(new HttpClientCodec());
}
else
{
ch.Pipeline.AddFirst(new HttpRequestEncoder(), new HttpResponseDecoder());
}
// We need to first write the request as HttpClientCodec will fail if we receive a response before a request
// was written.
shaker.HandshakeAsync(ch).Wait();
for (; ;)
{
// Just consume the bytes, we are not interested in these.
var buf = ch.ReadOutbound <IByteBuffer>();
if (buf == null)
{
break;
}
buf.Release();
}
Assert.True(ch.WriteInbound(compositeByteBuf));
Assert.True(ch.Finish());
var frame = ch.ReadInbound <BinaryWebSocketFrame>();
IByteBuffer expect = Unpooled.WrappedBuffer(data);
try
{
Assert.Equal(expect, frame.Content);
Assert.True(frame.IsFinalFragment);
Assert.Equal(0, frame.Rsv);
}
finally
{
expect.Release();
frame.Release();
}
}
public Handshaker(WebSocketClientHandshaker shaker)
: base(shaker.Uri, shaker.Version, null, EmptyHttpHeaders.Default, int.MaxValue, -1L)
{
this.shaker = shaker;
}
public DotNettyTestWebStockHandler(WebSocketClientHandshaker handshaker) : base(handshaker)
{
}