private async Task StartUdpChannel(string address, int port, IDiscoveryManager discoveryManager, IMessageSerializationService service)
{
var group = new MultithreadEventLoopGroup(1);
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Handler(new ActionChannelInitializer <IDatagramChannel>(x => InitializeChannel(x, discoveryManager, service)));
_channels.Add(await bootstrap.BindAsync(IPAddress.Parse(address), port));
}
public async Task StartAsync()
{
IEventLoopGroup workerGroup = new MultithreadEventLoopGroup();
if (_options.ProtocolType == ProtocolType.Tcp)
{
IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
var bootstrap = new ServerBootstrap();
bootstrap
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>();
bootstrap
.Option(ChannelOption.SoBacklog, 8192)
.Handler(new LoggingHandler("SRV-LSTN"))
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (_options.Ssl)
{
var tlsCertificate = new X509Certificate2(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "dotnetty.com.pfx"), "password");
pipeline.AddLast("tls", TlsHandler.Server(tlsCertificate));
}
pipeline.AddLast(new LoggingHandler("SRV-CONN"));
pipeline.AddLast(new IdleStateHandler(TimeSpan.FromHours(8), TimeSpan.FromHours(8), TimeSpan.FromHours(8)));
if (_options.SocketMode == SocketMode.Socket)
{
pipeline.AddLast("framing-enc", new DotNettyMessageEncoder(_packetCodec));
pipeline.AddLast("framing-dec", new DotNettyMessageDecoder(_packetCodec));
pipeline.AddLast(new SocketServerHandler <PacketInfo>(_serviceProvider, true));
}
else // websocket support
{
pipeline.AddLast(new HttpServerCodec());
pipeline.AddLast("framing-enc", new DotNettyMessageWebSocketEncoder(_packetCodec));
pipeline.AddLast(new HttpObjectAggregator(65536));
pipeline.AddLast(new WebSocketServerHandler(_serviceProvider, _options));
}
}));
_boundChannel = await bootstrap.BindAsync(_options.Port).ConfigureAwait(false);
}
else
{
var bootstrap = new Bootstrap();
bootstrap
.Group(workerGroup)
.Channel <SocketDatagramChannel>();
_boundChannel = await bootstrap.BindAsync(_options.Port).ConfigureAwait(false);
}
}
public void init(IExecutorPool executorPool, KcpListener kcpListener, ChannelConfig channelConfig, params int[] ports)
{
if (channelConfig.UseConvChannel)
{
int convIndex = 0;
if (channelConfig.Crc32Check)
{
convIndex += Ukcp.HEADER_CRC;
}
if (channelConfig.FecDataShardCount != 0 && channelConfig.FecParityShardCount != 0)
{
convIndex += Fec.fecHeaderSizePlus2;
}
_channelManager = new ServerConvChannelManager(convIndex);
}
else
{
_channelManager = new ServerEndPointChannelManager();
}
int cpuNum = Environment.ProcessorCount;
int bindTimes = cpuNum;
_eventLoopGroup = new MultithreadEventLoopGroup(cpuNum);
_scheduleThread = new HashedWheelScheduleThread();
_bootstrap = new Bootstrap();
//TODO epoll模型 服务器端怎么支持？得试试成功没有
_bootstrap.Option(ChannelOption.SoReuseport, true);
_bootstrap.Option(ChannelOption.SoReuseaddr, true);
_bootstrap.Group(_eventLoopGroup);
_bootstrap.ChannelFactory(() => new SocketDatagramChannel(AddressFamily.InterNetwork));
_bootstrap.Handler(new ActionChannelInitializer <SocketDatagramChannel>(channel =>
{
var pipeline = channel.Pipeline;
pipeline.AddLast(new ServerChannelHandler(_channelManager, channelConfig, executorPool, kcpListener, _scheduleThread));
}));
foreach (var port in ports)
{
// for (int i = 0; i < bindTimes; i++) {
var task = Task.Run(() => _bootstrap.BindAsync(port));
task.Wait();
var channel = task.Result;
_localAddress.Add(channel);
// }
}
//TODO 如何启动关闭进程的钩子??
}
private void StartUdpChannel()
{
//var address = new IPEndPoint(IPAddress.Parse(_configurationProvider.MasterHost), _configurationProvider.MasterPort);
//var address = _nodeTable.MasterNode.Address;
_logger.Info($"Starting UDP Channel: {_configurationProvider.MasterHost}:{_configurationProvider.MasterPort}");
var bootstrap = new Bootstrap();
bootstrap
.Group(_group)
.Channel <SocketDatagramChannel>()
.Handler(new ActionChannelInitializer <IDatagramChannel>(InitializeChannel));
_bindingTask = bootstrap.BindAsync(IPAddress.Parse(_configurationProvider.MasterHost), _configurationProvider.MasterPort).ContinueWith(t => _channel = t.Result);
}
static async Task RunClientAsync()
{
var group = new MultithreadEventLoopGroup();
try
{
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast("Logging", new LoggingClientHandler());
}));
IChannel clientChannel = await bootstrap.BindAsync(IPEndPoint.MinPort);
Console.WriteLine("Sending");
byte[] bytes = Encoding.UTF8.GetBytes("Hello");
IByteBuffer buffer = Unpooled.WrappedBuffer(bytes);
var ipaddrList = await Dns.GetHostAddressesAsync("localhost");
var remoteIp = ipaddrList.FirstOrDefault(x => x.AddressFamily == AddressFamily.InterNetwork);
if (remoteIp == null)
{
throw new Exception($"Can not resolve ip of ");
}
await clientChannel.WriteAndFlushAsync(
new DatagramPacket(
buffer,
new IPEndPoint(remoteIp, 6253)));
Console.WriteLine("Waiting for response.");
await Task.Delay(5000);
Console.WriteLine("Waiting for response time 5000 completed. Closing client channel.");
await clientChannel.CloseAsync();
}
finally
{
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
}
}
public async void Start()
{
int port = Args.Instance.Node.ListenPort;
IEventLoopGroup group = new MultithreadEventLoopGroup(Args.Instance.Node.UdpNettyWorkThreadNum);
try
{
this.discover_executor = new DiscoverExecutor(Manager.Instance.NodeManager);
this.discover_executor.Start();
while (!this.is_shutdown)
{
if (this.channel == null || !this.channel.Active)
{
Bootstrap bootstrap = new Bootstrap();
bootstrap.Group(group);
bootstrap.Channel <SocketDatagramChannel>();
bootstrap.Handler(new ActionChannelInitializer <SocketDatagramChannel>(channel =>
{
channel.Pipeline.AddLast(Manager.Instance.TrafficStats.UDP);
channel.Pipeline.AddLast(new ProtobufVarint32LengthFieldPrepender());
channel.Pipeline.AddLast(new ProtobufVarint32FrameDecoder());
channel.Pipeline.AddLast(new PacketDecoder());
MessageHandler message_handler = new MessageHandler(channel, Manager.Instance.NodeManager);
Manager.Instance.NodeManager.MessageSender = message_handler;
channel.Pipeline.AddLast(message_handler);
}));
this.channel = await bootstrap.BindAsync(port);
Logger.Info(
string.Format("Discovery server started, bind port {0}", port));
}
else
{
Thread.Sleep(10 * 1000);
}
}
}
catch (System.Exception e)
{
Logger.Error(
string.Format("Start discovery server with port {0} failed.", port), e);
}
finally
{
await group.ShutdownGracefullyAsync();
}
}
private async void Start()
{
IEventLoopGroup worker_group = new MultithreadEventLoopGroup(1);
try
{
while (!this.is_shutdown)
{
if (channel == null || !channel.Active)
{
Bootstrap bootstrap = new Bootstrap();
bootstrap.Group(worker_group);
bootstrap.Channel <SocketDatagramChannel>();
bootstrap.Handler(new ActionChannelInitializer <SocketDatagramChannel>(channel =>
{
channel.Pipeline.AddLast(Manager.Instance.TrafficStats.UDP);
channel.Pipeline.AddLast(new ProtobufVarint32LengthFieldPrepender());
channel.Pipeline.AddLast(new ProtobufVarint32FrameDecoder());
channel.Pipeline.AddLast(new PacketDecoder());
MessageHandler handler = new MessageHandler(channel, Manager.Instance.BackupManager);
Manager.Instance.BackupManager.MessageHandler = handler;
channel.Pipeline.AddLast(handler);
}));
this.channel = await bootstrap.BindAsync(port);
Logger.Info("Backup server started, bind port " + this.port);
}
else
{
Thread.Sleep(10 * 1000);
}
}
await this.channel.CloseAsync();
}
catch (System.Exception)
{
Logger.Error(
string.Format("Start backup server with port {0} failed", this.port));
}
finally
{
await Task.WhenAll(worker_group.ShutdownGracefullyAsync());
}
}
private void InitializeUdpChannel()
{
if (_logger.IsInfo)
{
_logger.Info($"Starting Discovery UDP Channel: {_configurationProvider.MasterHost}:{_configurationProvider.MasterPort}");
}
_group = new MultithreadEventLoopGroup(1);
var bootstrap = new Bootstrap();
bootstrap
.Group(_group)
.Channel <SocketDatagramChannel>()
.Handler(new ActionChannelInitializer <IDatagramChannel>(InitializeChannel));
_bindingTask = bootstrap.BindAsync(IPAddress.Parse(_configurationProvider.MasterHost), _configurationProvider.MasterPort)
.ContinueWith(t => _channel = t.Result);
}
public IChannel bindLocal(EndPoint localAddress = null)
{
if (localAddress == null)
{
localAddress = new IPEndPoint(IPAddress.Any, 0);
}
//#if UNITY_5_3_OR_NEWER
//var task = bootstrap.BindAsync(localAddress);
//task.Wait();
var task = Task.Run(() => bootstrap.BindAsync(localAddress));
task.Wait();
return(task.Result);
//#else
// return bootstrap.BindAsync(localAddress).Result;
//#endif
}
static async Task Main(string[] args)
{
ExampleHelper.SetConsoleLogger();
var group = new MultithreadEventLoopGroup();
try
{
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(new LoggingHandler("CONN"));
channel.Pipeline.AddLast("Quote", new QuoteOfTheMomentClientHandler());
}));
IChannel clientChannel = await bootstrap.BindAsync(IPEndPoint.MinPort);
Console.WriteLine("Sending broadcast QOTM");
// Broadcast the QOTM request to port.
byte[] bytes = Encoding.UTF8.GetBytes("QOTM?");
IByteBuffer buffer = Unpooled.WrappedBuffer(bytes);
await clientChannel.WriteAndFlushAsync(
new DatagramPacket(
buffer,
new IPEndPoint(IPAddress.Broadcast, ClientSettings.Port)));
Console.WriteLine("Waiting for response.");
await Task.Delay(5000);
Console.WriteLine("Waiting for response time 5000 completed. Closing client channel.");
await clientChannel.CloseAsync();
}
finally
{
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
}
}
//UDP 접속 함수. 연결할 서버의 UDP 리스닝 포트번호를 입력함.
public static void initUDPConnection(int setPort = -1)
{
try
{
//클라이언트의 UDP포트 바인딩 작업. (비동기로 실행됨)
Task <IChannel> bindingTask = udpBootstrap.BindAsync(0);
//바인딩 작업이 끝났다면 실행되는 델리게이트 함수.
bindingTask.GetAwaiter().OnCompleted(() =>
{
try
{
//바인딩된 udpChannel를 결과로 받아옴.
udpChannel = bindingTask.Result;
//지정된 포트가 존재한다면 해당 포트로 연결 시도! 지정되있지 않다면 ConnectGameServer 에서 지정된 주소로 연결함.
if (setPort != -1)
{
serverAddress_UDP.Port = setPort;
}
//서버의 UDP포트로 연결할 작업을 진행.
//(이 과정이 완료되면 위의 바인딩때 지정된 0번포트에서, 운영체제에서 자동으로 할당된 포트로 UDP채널이 최종 바인딩 되고, 송수신 가능한 상태가 된다)
Task connectTask = udpChannel.ConnectAsync(serverAddress_UDP);
//연결 작업이 완료되었다면.
connectTask.GetAwaiter().OnCompleted(() =>
{
//완료된 ip주소, port값 출력.
Debug.Log("initUDPConnection Complete [" + serverAddress_UDP.Address.ToString() + ":" + serverAddress_UDP.Port + "]");
});
}
catch (Exception e)
{
Debug.Log("UDP Connect Error:" + e.ToString());
}
});
}
catch (Exception e)
{
Debug.Log("UDP Bind Error:" + e.ToString());
}
}
private static async Task RunServerAsync()
{
LoggingHelper.SetNLogLogger();
IEventLoopGroup group = new MultithreadEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new QuoteOfTheMomentServerHandler());
IChannel channel = await b.BindAsync(Port);
await channel.CloseCompletion;
} finally {
await group.ShutdownGracefullyAsync();
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
workerGroup = new MultithreadEventLoopGroup(configuration.EventLoopCount);
var bootstrap = new Bootstrap();
bootstrap.Group(workerGroup)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new UdpHandler(Provider.GetRequiredService <ILogger <UdpHandler> >()));
var lengthFieldLength = configuration.LengthFieldLength;
pipeline.AddLast(new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian,
configuration.MaxFrameLength, 0, lengthFieldLength, 0, lengthFieldLength, true));
pipeline.AddLast(new RequestDecoder(decoder), new UdpLengthFieldPrepender(lengthFieldLength), new ResponseEncoder(encoder), handler);
}));
logger.LogInformation($"Server start at {IPAddress.Any}:{configuration.Port}.");
bootstrapChannel = await bootstrap.BindAsync(configuration.Port);
}
public async Task StartAsync()
{
try
{
if (group == null)
{
group = new MultithreadEventLoopGroup();
}
if (bootstrap == null)
{
bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new ActionChannelInitializer <IChannel>(ch =>
{
IChannelPipeline pipeline = ch.Pipeline;
_event.OnPipelineAction?.Invoke(pipeline);
pipeline.AddLast(new UdpHandler(_event));
}));
}
if (_ipAddress == null)
{
_ipAddress = IPAddress.Any;
}
await Stop();
channel = await bootstrap.BindAsync(_ipAddress, _port);
_event.OnStartAction?.Invoke();
}
catch (Exception ex)
{
_event.OnStopAction?.Invoke(ex);
}
}
public async Task StartAsync(EndPoint endPoint)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备启动服务主机，监听地址：{endPoint}。");
}
var group = new MultithreadEventLoopGroup();
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Handler(new ActionChannelInitializer <IDatagramChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new DatagramDnsQueryDecoder());
pipeline.AddLast(new DatagramDnsResponseEncoder());
pipeline.AddLast(new ServerHandler(async(contenxt, message) =>
{
var sender = new DotNettyDnsServerMessageSender(_transportMessageEncoder, contenxt);
await OnReceived(sender, message);
}, _logger));
})).Option(ChannelOption.SoBroadcast, true);
try
{
_channel = await bootstrap.BindAsync(endPoint);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"DNS服务主机启动成功，监听地址：{endPoint}。");
}
}
catch
{
_logger.LogError($"DNS服务主机启动失败，监听地址：{endPoint}。 ");
}
}
private void InitializeUdpChannel()
{
if (_logger.IsDebug)
{
_logger.Debug($"Discovery : udp://{_networkConfig.ExternalIp}:{_networkConfig.DiscoveryPort}");
}
ThisNodeInfo.AddInfo("Discovery :", $"udp://{_networkConfig.ExternalIp}:{_networkConfig.DiscoveryPort}");
_group = new MultithreadEventLoopGroup(1);
Bootstrap bootstrap = new Bootstrap();
bootstrap.Group(_group);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
bootstrap.ChannelFactory(() => new SocketDatagramChannel(AddressFamily.InterNetwork))
.Handler(new ActionChannelInitializer <IDatagramChannel>(InitializeChannel));
}
else
{
bootstrap.Channel <SocketDatagramChannel>()
.Handler(new ActionChannelInitializer <IDatagramChannel>(InitializeChannel));
}
_bindingTask = bootstrap.BindAsync(IPAddress.Parse(_networkConfig.LocalIp), _networkConfig.DiscoveryPort)
.ContinueWith(
t
=>
{
if (t.IsFaulted)
{
_logger.Error("Error when establishing discovery connection", t.Exception);
}
return(_channel = t.Result);
});
}
public async Task TestBindDeadLock()
{
Bootstrap bootstrapA = new Bootstrap();
bootstrapA.Group(_groupA);
bootstrapA.Channel <LocalChannel>();
bootstrapA.Handler(_dummyHandler);
Bootstrap bootstrapB = new Bootstrap();
bootstrapB.Group(_groupB);
bootstrapB.Channel <LocalChannel>();
bootstrapB.Handler(_dummyHandler);
var bindFutures = new List <Task <int> >();
// Try to bind from each other.
for (int i = 0; i < 1024; i++)
{
bindFutures.Add(_groupA.GetNext().SubmitAsync(() =>
{
bootstrapB.BindAsync(LocalAddress.Any);
return(i);
}));
bindFutures.Add(_groupB.GetNext().SubmitAsync(() =>
{
bootstrapA.BindAsync(LocalAddress.Any);
return(i);
}));
}
for (int i = 0; i < bindFutures.Count; i++)
{
Task <int> result = bindFutures[i];
await result;
}
}
/// <summary>
/// start as an asynchronous operation.
/// </summary>
/// <param name="endPoint">The end point.</param>
public async Task StartAsync(EndPoint endPoint)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备启动Udp服务主机，监听地址：{endPoint}。");
}
var group = new MultithreadEventLoopGroup();
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBacklog, 1024)
.Option(ChannelOption.SoSndbuf, 1024 * 4096 * 10)
.Option(ChannelOption.SoRcvbuf, 1024 * 4096 * 10)
.Handler(new ServerHandler(async(contenxt, message) =>
{
var sender = new DotNettyUdpServerMessageSender(_transportMessageEncoder, contenxt);
await OnReceived(sender, message);
}, _logger, _serializer)
).Option(ChannelOption.SoBroadcast, true);
try
{
_channel = await bootstrap.BindAsync(endPoint);
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"Udp服务主机启动成功，监听地址：{endPoint}。");
}
}
catch (Exception ex)
{
_logger.LogError($"Udp服务主机启动失败，监听地址：{endPoint}。 ");
}
}
public async Task <bool> BindPortAsync(SimpleChannelInboundHandler <DatagramPacket> telloClientHandler, string name)
{
try
{
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Channel <SocketDatagramChannel>()
.Option(ChannelOption.SoBroadcast, true)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(name, telloClientHandler);
}));
clientChannel = await bootstrap.BindAsync(IPEndPoint.MinPort);
return(true);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(false);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_boundChannel = await _bootstrap.BindAsync(_options.Port);
Console.WriteLine($"UDP server started at 0.0.0.0:{_options.Port}");
}
public IDisposable Run()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
var subscription = Observable
.Create <object>(async(observer, cancellationToken) =>
{
try
{
Bootstrap serverBootstrap = new Bootstrap();
MultithreadEventLoopGroup serverGroup = new MultithreadEventLoopGroup(1);
try
{
serverBootstrap
.Group(serverGroup)
.ChannelFactory(() => new SocketDatagramChannel(_addressFamily))
.Option(ChannelOption.Allocator, PooledByteBufferAllocator.Default)
.Option(ChannelOption.SoReuseaddr, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel => { channel.Pipeline.AddLast(this); }));
SocketDatagramChannel serverChannel = (SocketDatagramChannel)await serverBootstrap
.BindAsync(IPAddress.Any, _discoveryServerPort)
.ConfigureAwait(false);
try
{
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
using (cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken), false))
{
resetEvent.Set();
await tcs.Task.ConfigureAwait(false);
}
}
finally
{
await serverChannel
.CloseAsync()
.ConfigureAwait(false);
}
}
finally
{
await serverGroup
.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))
.ConfigureAwait(false);
}
observer.OnCompleted();
}
catch (OperationCanceledException)
{
observer.OnCompleted();
}
catch (Exception e)
{
observer.OnError(e);
}
})
.Subscribe();
resetEvent.WaitOne();
return(subscription);
}
public void SimpleSend(IByteBuffer source, bool bindClient, IByteBufferAllocator allocator, AddressFamily addressFamily, byte[] expectedData, int count)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return;
}
SocketDatagramChannel serverChannel = null;
IChannel clientChannel = null;
var serverGroup = new MultithreadEventLoopGroup(1);
var clientGroup = new MultithreadEventLoopGroup(1);
try
{
var handler = new TestHandler(expectedData);
var serverBootstrap = new Bootstrap();
serverBootstrap
.Group(serverGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoBroadcast, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(nameof(SocketDatagramChannelUnicastTest), handler);
}));
IPAddress address = NetUtil.GetLoopbackAddress(addressFamily);
this.Output.WriteLine($"Unicast server binding to:({addressFamily}){address}");
Task <IChannel> task = serverBootstrap.BindAsync(address, IPEndPoint.MinPort);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Unicast server binding to:({addressFamily}){address} timed out!");
serverChannel = (SocketDatagramChannel)task.Result;
var endPoint = (IPEndPoint)serverChannel.LocalAddress;
var clientBootstrap = new Bootstrap();
clientBootstrap
.Group(clientGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoBroadcast, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast("Dummy", new NetUtil.DummyHandler());
}));
var clientEndPoint = new IPEndPoint(
addressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any,
IPEndPoint.MinPort);
clientBootstrap
.LocalAddress(clientEndPoint)
.RemoteAddress(new IPEndPoint(address, endPoint.Port));
if (bindClient)
{
this.Output.WriteLine($"Unicast client binding to:({addressFamily}){address}");
task = clientBootstrap.BindAsync(clientEndPoint);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Unicast client binding to:({clientEndPoint}) timed out!");
clientChannel = task.Result;
}
else
{
this.Output.WriteLine($"Register client binding to:({addressFamily}){address}");
task = (Task <IChannel>)clientBootstrap.RegisterAsync();
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds)), "Unicast client register timed out!");
clientChannel = task.Result;
}
for (int i = 0; i < count; i++)
{
var packet = new DatagramPacket((IByteBuffer)source.Retain(), new IPEndPoint(address, endPoint.Port));
clientChannel.WriteAndFlushAsync(packet).Wait();
Assert.True(handler.WaitForResult());
var duplicatedPacket = (DatagramPacket)packet.Duplicate();
duplicatedPacket.Retain();
clientChannel.WriteAndFlushAsync(duplicatedPacket).Wait();
Assert.True(handler.WaitForResult());
}
}
finally
{
serverChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
clientChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
source.Release();
Task.WaitAll(
serverGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)),
clientGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)));
}
}
public IObservable <IPEndPoint[]> MakeObservable()
{
return(Observable.Create <IPEndPoint[]>(async(observer, cancellationToken) =>
{
try
{
Bootstrap clientBootstrap = new Bootstrap();
MultithreadEventLoopGroup clientGroup = new MultithreadEventLoopGroup(1);
try
{
clientBootstrap
.Group(clientGroup)
.ChannelFactory(() => new SocketDatagramChannel(_addressFamily))
.Option(ChannelOption.Allocator, PooledByteBufferAllocator.Default)
.Option(ChannelOption.SoReuseaddr, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(new SimpleChannelInboundHandler(_endPoints));
}));
SocketDatagramChannel clientChannel = (SocketDatagramChannel)await clientBootstrap
.BindAsync(IPAddress.Any, IPEndPoint.MinPort)
.ConfigureAwait(false);
try
{
IPEndPoint multicastEndPoint = new IPEndPoint(_multicastAddress, _disconveryServerPort);
byte[] groupBytes = Encoding.UTF8.GetBytes(_group);
IByteBuffer message = PooledByteBufferAllocator.Default
.Buffer()
.WriteInt(groupBytes.Length)
.WriteBytes(groupBytes);
DatagramPacket dataGram = new DatagramPacket(message, multicastEndPoint);
while (!cancellationToken.IsCancellationRequested)
{
_endPoints.Clear();
await clientChannel
.WriteAndFlushAsync(dataGram.Copy())
.ConfigureAwait(false);
await Task
.Delay(_replyWaitTimeout, cancellationToken)
.ConfigureAwait(false);
observer.OnNext(_endPoints.ToArray());
await Task
.Delay(_pollingInterval, cancellationToken)
.ConfigureAwait(false);
}
}
finally
{
await clientChannel
.CloseAsync()
.ConfigureAwait(false);
}
}
finally
{
await clientGroup
.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))
.ConfigureAwait(false);
}
observer.OnCompleted();
}
catch (OperationCanceledException)
{
observer.OnCompleted();
}
catch (Exception exception)
{
observer.OnError(exception);
}
})
.DistinctUntilChanged(endPoints => string.Join(";", endPoints.Select(endPoint => endPoint.ToString()))));
}
public Boolean Init(ConnectionListener<string> listener, IPEndPoint localEndPoint, string certFile, string certPassword, bool fLoadWholeChain)
{
if (channel == null)
{
this._listener = listener;
bootstrap = new Bootstrap();
loopGroup = new MultithreadEventLoopGroup(workerThreads);
bootstrap.Group(loopGroup);
bootstrap.Channel<SocketDatagramChannel>();
UDPClient currClient = this;
bootstrap.Handler(new ActionChannelInitializer<SocketDatagramChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (isSecured)
{
Pkcs12Store keystore = null;
if (certificate != null && certificate.Length > 0)
keystore = CertificatesHelper.loadBC(certificate, certificatePassword);
AsyncDtlsClient client = new MyAsyncDtlsClient(certFile, certPassword, fLoadWholeChain);
_clientProtocol = new AsyncDtlsClientProtocol(client, new SecureRandom(), channel, currClient, true, ProtocolVersion.DTLSv12);
pipeline.AddLast(new DtlsClientHandler(_clientProtocol, this));
}
pipeline.AddLast("handler", new RawMessageHandler(listener));
#if false
pipeline.AddLast(new CoapEncoder(channel));
pipeline.AddLast(new ExceptionHandler());
#endif
}));
bootstrap.RemoteAddress(address);
#if true
try
{
Task<IChannel> task;
if (localEndPoint != null)
{
task = bootstrap.BindAsync(localEndPoint);
}
else
{
task = bootstrap.BindAsync(IPEndPoint.MinPort);
}
task.GetAwaiter().OnCompleted(() =>
{
try
{
channel = task.Result;
Task connectTask = channel.ConnectAsync(address);
connectTask.GetAwaiter().OnCompleted(() =>
{
if (_clientProtocol == null)
{
if (channel != null)
listener.Connected();
else
listener.ConnectFailed();
}
else
{
startHandhshakeTimer();
_clientProtocol.InitHandshake(null);
}
});
}
catch (Exception)
{
listener.ConnectFailed();
return;
}
});
}
catch (Exception)
{
return false;
}
}
#endif
return true;
}
public void Multicast(AddressFamily addressFamily, IByteBufferAllocator allocator)
{
SocketDatagramChannel serverChannel = null;
IChannel clientChannel = null;
var serverGroup = new MultithreadEventLoopGroup(1);
var clientGroup = new MultithreadEventLoopGroup(1);
NetworkInterface loopback = NetUtil.LoopbackInterface(addressFamily);
try
{
var multicastHandler = new MulticastTestHandler();
var serverBootstrap = new Bootstrap();
serverBootstrap
.Group(serverGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoReuseaddr, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(nameof(SocketDatagramChannelMulticastTest), multicastHandler);
}));
IPAddress address = addressFamily == AddressFamily.InterNetwork
? IPAddress.Loopback : IPAddress.IPv6Loopback;
this.Output.WriteLine($"Multicast server binding to:({addressFamily}){address}");
Task <IChannel> task = serverBootstrap.BindAsync(address, IPEndPoint.MinPort);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Multicast server binding to:({addressFamily}){address} timed out!");
serverChannel = (SocketDatagramChannel)task.Result;
var serverEndPoint = (IPEndPoint)serverChannel.LocalAddress;
var clientBootstrap = new Bootstrap();
clientBootstrap
.Group(clientGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoReuseaddr, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast("Dummy", new NetUtil.DummyHandler());
}));
this.Output.WriteLine($"Multicast client binding to:({addressFamily}){address}");
task = clientBootstrap.BindAsync(address, IPEndPoint.MinPort);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Multicast client binding to:({addressFamily}){address} timed out!");
clientChannel = (SocketDatagramChannel)task.Result;
IPAddress multicastAddress = addressFamily == AddressFamily.InterNetwork
? IPAddress.Parse("230.0.0.1") : IPAddress.Parse("ff12::1");
var groupAddress = new IPEndPoint(multicastAddress, serverEndPoint.Port);
Task joinTask = serverChannel.JoinGroup(groupAddress, loopback);
Assert.True(joinTask.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Multicast server join group {groupAddress} timed out!");
clientChannel.WriteAndFlushAsync(new DatagramPacket(Unpooled.Buffer().WriteInt(1), groupAddress)).Wait();
Assert.True(multicastHandler.WaitForResult(), "Multicast server should have receivied the message.");
Task leaveTask = serverChannel.LeaveGroup(groupAddress, loopback);
Assert.True(leaveTask.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Multicast server leave group {groupAddress} timed out!");
// sleep half a second to make sure we left the group
Task.Delay(DefaultTimeOutInMilliseconds).Wait();
// we should not receive a message anymore as we left the group before
clientChannel.WriteAndFlushAsync(new DatagramPacket(Unpooled.Buffer().WriteInt(1), groupAddress)).Wait();
Assert.False(multicastHandler.WaitForResult(), "Multicast server should not receive the message.");
}
finally
{
serverChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
clientChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
Task.WaitAll(
serverGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)),
clientGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)));
}
}
public Boolean Init(ConnectionListener <SNMessage> listener)
{
if (channel == null)
{
this._listener = listener;
bootstrap = new Bootstrap();
loopGroup = new MultithreadEventLoopGroup(workerThreads);
bootstrap.Group(loopGroup);
bootstrap.Channel <SocketDatagramChannel>();
UDPClient currClient = this;
bootstrap.Handler(new ActionChannelInitializer <SocketDatagramChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (isSecured)
{
Pkcs12Store keystore = null;
if (certificate != null && certificate.Length > 0)
{
keystore = CertificatesHelper.loadBC(certificate, certificatePassword);
}
AsyncDtlsClient client = new AsyncDtlsClient(keystore, certificatePassword, null);
_clientProtocol = new AsyncDtlsClientProtocol(client, new SecureRandom(), channel, null, currClient, true, ProtocolVersion.DTLSv12);
pipeline.AddLast(new DtlsClientHandler(_clientProtocol, this));
}
pipeline.AddLast("handler", new SNHandler(listener));
pipeline.AddLast("encoder", new SNEncoder(channel));
pipeline.AddLast(new ExceptionHandler());
}));
bootstrap.RemoteAddress(address);
try
{
com.mobius.software.windows.iotbroker.mqtt_sn.net.UDPClient curr = this;
Task <IChannel> task = bootstrap.BindAsync(IPEndPoint.MinPort);
task.GetAwaiter().OnCompleted(() =>
{
try
{
channel = task.Result;
Task connectTask = channel.ConnectAsync(address);
connectTask.GetAwaiter().OnCompleted(() =>
{
if (_clientProtocol == null)
{
if (channel != null)
{
listener.Connected();
}
else
{
listener.ConnectFailed();
}
}
else
{
startHandhshakeTimer();
_clientProtocol.InitHandshake(null);
}
});
}
catch (Exception)
{
listener.ConnectFailed();
return;
}
});
}
catch (Exception)
{
return(false);
}
}
return(true);
}
