static void RobotControl()
{
var team = RobocupTeam.Yellow;
var robotId = 1;
var robotCount = 8;
using var output = (ICommandsOutput) new GrSimCommandsOutput(team, IPEndPoint.Parse("127.0.0.1:20011"));
using var gamepad = EvDevDeviceInfo.EnumerateDevices()
.Single(_ => _.DevicePath == "/dev/input/event25").OpenGamepad();
var commands = Enumerable.Repeat(RobotCommand.Idle, robotCount).ToArray();
var rnd = new Random();
while (true)
{
Console.WriteLine("{0:#0.000} {1:#0.000} {2:#0.000} {3:#0.000}", gamepad.LeftX.Value, gamepad.LeftY.Value,
gamepad.RightX.Value, gamepad.RightY.Value);
commands[robotId].VelocityTangent = gamepad.LeftY.Value;
commands[robotId].VelocityNormal = gamepad.LeftX.Value;
commands[robotId].AngularVelocity = gamepad.RightX.Value * 10;
commands[robotId].EnableDribbler = true;
output.PostCommands(commands.ToArray());
Thread.Sleep(1000 / 60);
}
}
public void TestAccountLoginAck()
{
var info = new[]
{
new ServerInfo("Test Server", 0, TimeZoneInfo.Local, IPEndPoint.Parse("127.0.0.1"))
};
var data = new AccountLoginAck(info).Compile();
Span <byte> expectedData = stackalloc byte[6 + info.Length * 40];
var pos = 0;
expectedData.Write(ref pos, (byte)0xA8); // Packet ID
expectedData.Write(ref pos, (ushort)expectedData.Length);
expectedData.Write(ref pos, (byte)0x5D); // Unknown
expectedData.Write(ref pos, (ushort)info.Length);
for (var i = 0; i < info.Length; i++)
{
var si = info[i];
expectedData.Write(ref pos, (ushort)i);
expectedData.WriteAsciiFixed(ref pos, si.Name, 32);
expectedData.Write(ref pos, (byte)si.FullPercent);
expectedData.Write(ref pos, (byte)si.TimeZone);
expectedData.Write(ref pos, Utility.GetAddressValue(si.Address.Address));
}
AssertThat.Equal(data, expectedData);
}
private static ImmutableArray <ConcurrentQueue <ICommand> > StartFileServerThreads(string[] args)
{
var fileServersCount = args.Length;
Console.WriteLine($"Configuring {fileServersCount} file servers...");
var queues = Enumerable.Range(0, fileServersCount)
.Select(i => new ConcurrentQueue <ICommand>())
.ToImmutableArray();
var threads = new FileServerThread[fileServersCount];
for (var i = 0; i < fileServersCount; i++)
{
var serverIndex = i;
var remote = IPEndPoint.Parse(args[i]);
var threadPort = Port + 1 + serverIndex;
threads[i] = new FileServerThread(threadPort, remote, serverIndex, Responses, queues[serverIndex]);
}
foreach (var thread in threads)
{
thread.Start();
}
return(queues);
}
//teamID和playID不能超过32位，否则会GG
static int Main(string[] args)
{
var app = new CommandLineApplication();
app.HelpOption("-h|--help");
var server = app.Option("-s|--server", "game server endpoint.", CommandOptionType.SingleValue);
var port = app.Option("-p|--port", "agent port, 7777 indefault", CommandOptionType.SingleValue);
app.OnExecute(() =>
{
string endpoint = server.Value();
IPEndPoint serverend;
try
{
serverend = IPEndPoint.Parse(endpoint);
}
catch (Exception e)
{
Console.WriteLine("Parsing server endpoint went wrong:" + e.Message);
return(0);
}
string tt = port.Value();
ushort agentport;
agentport = string.IsNullOrEmpty(tt) ? (ushort)7777 : ushort.Parse(tt);
Console.WriteLine("Server endpoint:" + serverend.Address.ToString() + ":" + serverend.Port.ToString());
Console.WriteLine($"Agent port:{agentport}");
return(MainInternal(serverend, agentport));
});
app.Execute(args);
return(0);
}
private static Bits <T> SetupService <T>(params T[] result)
{
var commandValidator = new Mock <ICommandValidator>();
commandValidator
.Setup(x => x.Validate(It.IsAny <Command>(), out It.Ref <IEnumerable <string> > .IsAny))
.Returns(true);
var endpoint = IPEndPoint.Parse("127.0.0.1:12345") !;
var connection = new Mock <IControlConnection>();
var connectionPool = new Mock <IControlConnectionPool>();
connectionPool
.Setup(x => x.GetAsync(endpoint, It.IsAny <CancellationToken>()))
.ReturnsAsync(connection.Object);
var responseFactory = new Mock <IResponseFactory>();
responseFactory
.Setup(x => x.Create <T>(It.IsAny <CancellationToken>()))
.Returns(
new FutureResponse <T>(
123, Task.FromResult(new Response <T>(123, result))));
var service =
new CommandService(
commandValidator.Object,
connectionPool.Object,
responseFactory.Object);
return(new(endpoint, connection, service, commandValidator));
}
private void Parse_InvalidAddress_Throws(string address, bool isIPv4)
{
// TryParse should return false and set result to null
Assert.False(IPEndPoint.TryParse(address, out IPEndPoint result));
Assert.Null(result);
// Parse should throw
Assert.Throws <FormatException>(() => IPEndPoint.Parse(address));
int portNumber = 1;
for (int i = 0; i < 5; i++)
{
string addressAndPort = isIPv4 ? $"{address}:{portNumber}" : $"[{address}]:{portNumber}";
// TryParse should return false and set result to null
result = new IPEndPoint(IPAddress.Parse("0"), 25);
Assert.False(IPEndPoint.TryParse(addressAndPort, out result));
Assert.Null(result);
// Parse should throw
Assert.Throws <FormatException>(() => IPEndPoint.Parse(addressAndPort));
// i.e.: 1; 12; 123; 1234; 12345
portNumber *= 10;
portNumber += i + 2;
}
}
private Server GetServerFromHashEntries(HashEntry[] hashEntries)
{
var dictionary = hashEntries.ToDictionary();
return(new Server()
{
Host = new Player()
{
UserId = dictionary["HostUserId"],
UserName = dictionary["HostUserName"]
},
RemoteEndPoint = IPEndPoint.Parse(dictionary["RemoteEndPoint"]),
Code = dictionary["Code"],
IsPublic = (bool)dictionary["IsPublic"],
DiscoveryPolicy = (DiscoveryPolicy)(int)dictionary["DiscoveryPolicy"],
InvitePolicy = (InvitePolicy)(int)dictionary["InvitePolicy"],
BeatmapDifficultyMask = (BeatmapDifficultyMask)(int)dictionary["BeatmapDifficultyMask"],
GameplayModifiersMask = (GameplayModifiersMask)(int)dictionary["GameplayModifiersMask"],
SongPackBloomFilterTop = (ulong)dictionary["SongPackBloomFilterTop"],
SongPackBloomFilterBottom = (ulong)dictionary["SongPackBloomFilterBottom"],
CurrentPlayerCount = (int)dictionary["CurrentPlayerCount"],
MaximumPlayerCount = (int)dictionary["MaximumPlayerCount"],
Random = dictionary["Random"],
PublicKey = dictionary["PublicKey"]
});
}
public async Task TestSuccessAsync(string ip, int port)
{
await using var client = NewTCPingClient;
client.Timeout = TimeSpan.FromSeconds(3);
client.EndPoint = IPEndPoint.Parse($@"{ip}:{port}");
var res = await client.PingAsync(default);
public async Task ExtendedQueryEmptyQuery()
{
var endpoint = IPEndPoint.Parse(EndPoint);
using var db = await PgDB.OpenAsync(endpoint, UserName, Password, Database);
await db.ExecuteExtendedAsync(string.Empty);
await db.EnsureSinglePacketAsync();
var response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.ParseComplete);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.BindComplete);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.NoData);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.EmptyQueryResponse);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.ReadyForQuery);
}
static int Main(string[] args)
=> Task.Run(async() =>
{
Logger = new Logger(Console.Out);
if (args.Length >= 1)
{
serverEP = IPEndPoint.Parse(args[0]);
}
Log(LogLevel.Notice, $"Connecting to {serverEP}");
client = new Client(Logger);
try
{
await client.ConnectAsync(serverEP);
}
catch (SocketException e)
{
Log(LogLevel.Error, e.Message);
return(1);
}
Log(LogLevel.Notice, $"Connected to {serverEP}");
await client.RunAsync(MessageSendLoopAsync, MessageReceivedHandlerAsync);
// TODO cleanup
return(0);
}).Result;
public void addRoom_command_will_save()
{
var eventNamespace = "Registration.Blueprint.Events";
var eventAssembly = "Registration";
var settings = ConnectionSettings.Create()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
.KeepReconnecting()
.KeepRetrying()
//.UseConsoleLogger()
.Build();
var conn = EventStoreConnection.Create(settings, IPEndPoint.Parse("127.0.0.1:1113"));
conn.ConnectAsync().Wait();
var repo = new SimpleRepo(conn, eventNamespace, eventAssembly);
var roomSvc = new RoomSvc(repo);
var roomId = Guid.NewGuid();
roomSvc.Handle(new AddRoom(roomId, "12B", "2nd Floor", "King"));
var room = repo.Load <Room>(roomId);
Assert.Equal(roomId, ((IEventSource)room).Id);
}
public void Start(string listenSocks, string serverAddress, int serverPort, string method, string password, string?plugin, string?pluginOpts, string?pluginArgs)
{
var localEP = IPEndPoint.Parse(listenSocks);
var server = new Server()
{
Host = serverAddress,
Port = serverPort,
Method = method,
Password = password,
Plugin = plugin,
PluginOpts = pluginOpts,
};
if (!string.IsNullOrEmpty(plugin) && !string.IsNullOrEmpty(pluginArgs))
{
var processStartInfo = new ProcessStartInfo(plugin, pluginArgs);
server.PluginArgs = processStartInfo.ArgumentList.ToList();
}
var tcpRelay = new TCPRelay(server);
_tcpListener = new TCPListener(localEP, new List <IStreamService>()
{
tcpRelay,
});
_tcpListener.Start();
var udpRelay = new UDPRelay(server);
_udpListener = new UDPListener(localEP, new List <IDatagramService>()
{
udpRelay,
});
_udpListener.Start();
}
public async Task Discover_CancelBeforeFinish_ReturnsEmptyList()
{
// Arrange
CancellationTokenSource cancellation = new CancellationTokenSource();
Guid messageId = Guid.NewGuid();
TestCamera camera = null;
Mock <IOnvifUdpClient> udpClientMock = new Mock <IOnvifUdpClient> ();
udpClientFactoryMock.Setup(cf => cf.CreateClientForeachInterface()).Returns(new List <IOnvifUdpClient> {
udpClientMock.Object
});
udpClientMock.Setup(cl => cl.SendProbeAsync(It.IsAny <Guid> (), It.IsAny <IPEndPoint> ()))
.ReturnsAsync(200)
.Callback <Guid, IPEndPoint> ((mId, endpoint) => {
messageId = mId;
});
udpClientMock.Setup(udp => udp.ReceiveAsync())
.ReturnsAsync(() => {
camera = new TestCamera(messageId, Guid.NewGuid(), "AxisHardware", "AxisName", "192.168.1.12");
return(new UdpReceiveResult(Utils.CreateProbeResponse(camera), IPEndPoint.Parse("192.168.1.12")));
}).Callback(() => cancellation.Cancel());
// Act
var discoveredDevices = await wSDiscovery.Discover(1, cancellation.Token);
// Assert
discoveredDevices.Should().BeEmpty();
}
public async Task ProxyTest()
{
using var proxy = ProxyFactory.CreateProxy(ProxyType.Socks5, IPEndPoint.Parse(@"0.0.0.0:0"), IPEndPoint.Parse(@"127.0.0.1:10000"));
using var client = new StunClient5389UDP(@"stun.syncthing.net", 3478, new IPEndPoint(IPAddress.Any, 0), proxy);
await client.QueryAsync();
var result = client.Status;
Assert.AreEqual(result.BindingTestResult, BindingTestResult.Success);
Assert.IsNotNull(result.LocalEndPoint);
Assert.IsNotNull(result.PublicEndPoint);
Assert.IsNotNull(result.OtherEndPoint);
Assert.AreNotEqual(result.LocalEndPoint !.Address, IPAddress.Any);
Assert.IsTrue(
result.MappingBehavior is MappingBehavior.Direct
or MappingBehavior.EndpointIndependent
or MappingBehavior.AddressDependent
or MappingBehavior.AddressAndPortDependent);
Assert.IsTrue(
result.FilteringBehavior is FilteringBehavior.EndpointIndependent
or FilteringBehavior.AddressDependent
or FilteringBehavior.AddressAndPortDependent);
Console.WriteLine(result.BindingTestResult);
Console.WriteLine(result.MappingBehavior);
Console.WriteLine(result.FilteringBehavior);
Console.WriteLine(result.OtherEndPoint);
Console.WriteLine(result.LocalEndPoint);
Console.WriteLine(result.PublicEndPoint);
}
static MessageBenchmark()
{
var body = new Response("yess!");
Value = (new Message
{
TargetActivation = ActivationId.NewId(),
TargetSilo = SiloAddress.New(IPEndPoint.Parse("210.50.4.44:40902"), 5423123),
TargetGrain = GrainId.Create("sys.mygrain", "borken_thee_doggo"),
BodyObject = body,
InterfaceType = GrainInterfaceType.Create("imygrain"),
SendingActivation = ActivationId.NewId(),
SendingSilo = SiloAddress.New(IPEndPoint.Parse("10.50.4.44:40902"), 5423123),
SendingGrain = GrainId.Create("sys.mygrain", "fluffy_g"),
TraceContext = new TraceContext {
ActivityId = Guid.NewGuid()
},
Id = CorrelationId.GetNext()
}).Headers;
//
var services = new ServiceCollection()
.AddSerializer()
.BuildServiceProvider();
Serializer = services.GetRequiredService <Serializer <Message.HeadersContainer> >();
var bytes = new byte[4000];
Session = services.GetRequiredService <SerializerSessionPool>().GetSession();
var writer = new SingleSegmentBuffer(bytes).CreateWriter(Session);
Serializer.Serialize(Value, ref writer);
Input = bytes;
}
public async Task ExtendedQueryNoRows()
{
var endpoint = IPEndPoint.Parse(EndPoint);
using var db = await PgDB.OpenAsync(endpoint, UserName, Password, Database);
await db.ExecuteExtendedAsync("SELECT 1 WHERE 1 = 0");
await db.EnsureSinglePacketAsync();
var response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.ParseComplete);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.BindComplete);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.RowDescription);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.CommandComplete);
await db.EnsureSinglePacketAsync();
response = db.ReadPacket();
PgDB.ValidateResponseMessage(response, BackendMessageCode.ReadyForQuery);
}
public override void Send(byte[] data, string to = "")
{
try
{
var endpoint = IPEndPoint.Parse(to);
var state = new ReceiverState
{
Port = endpoint.Port,
Socket = ServerSocket,
Ip = endpoint.Address.ToString()
};
ServerSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, endpoint, OnSendToCallback, state);
OnReportingStatus(StatusCode.Info, $"Started sending {data.Length} bytes to {endpoint} via UDP socket");
}
catch (ObjectDisposedException)
{
}
catch (SocketException socketException)
{
OnCaughtException(socketException, EventCode.Send);
}
catch (Exception e)
{
OnCaughtException(e, EventCode.Other);
}
}
public static void AsService()
{
//Bootstrap
var settings = ConnectionSettings.Create()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
.KeepReconnecting()
.KeepRetrying()
//.UseConsoleLogger()
.Build();
var conn = EventStoreConnection.Create(settings, IPEndPoint.Parse("127.0.0.1:1113"));
conn.ConnectAsync().Wait();
var eventNamespace = "Registration.Blueprint.Events";
var eventAssembly = "Registration";
var repo = new SimpleRepo(conn, eventNamespace, eventAssembly);
var rm = new RoomsReader(() => conn, repo.Deserialize);
MainBus = new SimpleBus();
var roomSvc = new RoomSvc(repo);
MainBus.Subscribe <AddRoom>(roomSvc);
rm.Start();
RoomReadModel = rm;
}
public void ServerQuery_Success(params string[] addresses)
{
foreach (var address in addresses)
{
var server = KartQuery.QueryServer(IPEndPoint.Parse(address));
Assert.NotNull(server);
Assert.True(!string.IsNullOrWhiteSpace(server.Name));
Assert.True(!string.IsNullOrWhiteSpace(server.Application));
Assert.True(server.NumberOfFilesNeeded > 0); // SHOULD be > 0 for ALL SRB2Kart servers.
Assert.True(server.MaxPlayerCount > 0); // SHOULD be > 0 for ALL SRB2Kart servers. Imagine a 0 player server.
Assert.NotNull(server.CurrentMap);
Assert.True(!string.IsNullOrWhiteSpace(server.CurrentMap.Title));
Assert.True(!string.IsNullOrWhiteSpace(server.CurrentMap.InternalName));
Assert.True(server.CurrentMap.MD5.Length == 16);
Assert.True(server.CurrentMap.TimeElapsed > TimeSpan.Zero);
Assert.True(server.CurrentPlayerCount == server.CurrentPlayers.Length);
Assert.All(server.CurrentPlayers, player =>
{
Assert.True(player.Node != 255);
Assert.True(!string.IsNullOrWhiteSpace(player.Name));
Assert.True(player.TimeInServer > TimeSpan.Zero);
});
Assert.All(server.NeededFiles, file =>
{
Assert.True(!string.IsNullOrWhiteSpace(file.Filename));
Assert.True(file.Md5.Length == 16);
});
}
}
public static void ConfigureApp(RegistrationApp app, string eventNamespace, string eventAssembly)
{
var settings = ConnectionSettings.Create()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
.KeepReconnecting()
.KeepRetrying()
//.UseConsoleLogger()
.Build();
var conn = EventStoreConnection.Create(settings, IPEndPoint.Parse("127.0.0.1:1113"));
conn.ConnectAsync().Wait();
var repo = new SimpleRepo(conn, eventNamespace, eventAssembly);
var userRm = new RegisteredUsers(() => conn, repo.Deserialize);
var mainBus = new SimpleBus();
var userSvc = new UserSvc(repo);
mainBus.Subscribe <RegisterUser>(userSvc);
mainBus.Subscribe <ChangeName>(userSvc);
//application wire up
app.CommandPublisher = mainBus;
userRm.Subscribe(app.DisplayUsers);
//start
userRm.Start();
}
static void Main(string[] args)
{
var socket1 = ENetDatagramSocket.BindUdp(IPEndPoint.Parse("127.0.0.1:32888"));
Trace.Assert(socket1.EndPoint.Equals(socket1.Socket.LocalEndPoint) == true);
Trace.Assert(
socket1.Receive(suggestedBufferLength: -1, timeout: TimeSpan.Zero, receiveResult: out _) == false);
var socket2 = ENetDatagramSocket.BindUdp(IPEndPoint.Parse("127.0.0.1:0"));
var sendPayload = Encoding.UTF8.GetBytes("HelloWorld");
socket1.Send(sendPayload, socket2.EndPoint);
var didReceive =
socket2.Receive(-1, TimeSpan.FromMilliseconds(500), out var receiveResult);
Trace.Assert(didReceive == true);
Trace.Assert(receiveResult.PacketLength == sendPayload.Length);
Trace.Assert(receiveResult.RemoteEndPoint.Equals(socket1.EndPoint) == true);
var payloadsWereEqual =
receiveResult.PacketMemoryOwner.Memory.Slice(0, sendPayload.Length).Span.SequenceEqual(sendPayload);
Trace.Assert(payloadsWereEqual == true);
ReadOnlyMemory <byte> sendPayloadFirstHalf = sendPayload[..5];
public DNSCrypt(IOptionsMonitor <DNSCryptOptions> DNSCryptOptions)
{
Options = DNSCryptOptions;
Random = new Random();
Client = new UdpClient
{
Client =
{
SendTimeout = Options.CurrentValue.Timeout,
ReceiveTimeout = Options.CurrentValue.Timeout
}
};
Stamp = (DNSCryptStamp)Options.CurrentValue.Stamp.Value;
IPEndPoint = IPEndPoint.Parse(Stamp.Address);
var ClientCurve25519 = new Curve25519();
ClientPublicKey = ClientCurve25519.GetPublicKey();
ClientPrivateKey = ClientCurve25519.GetPrivateKey();
ChaCha20Poly1305 = new ChaCha20Poly1305();
IsInitialized = false;
}
public async Task Test1()
{
//Larva.MessageProcess.LoggerManager.SetLoggerProvider(new Log4NetLoggerProvider());
var consumer = new CommandConsumer();
consumer.Initialize(new ConsumerSettings
{
AmqpUri = new Uri("amqp://*****:*****@localhost/test")
}, "MessageProcess_CommandTopic", 4, false, 1, new IInterceptor[] { new PerformanceCounterInterceptor() }, typeof(CommandTests).Assembly);
consumer.Start();
var commandBus = new CommandBus();
commandBus.Initialize(new ProducerSettings
{
AmqpUri = new Uri("amqp://*****:*****@localhost/test")
}, "MessageProcess_CommandTopic", 4, IPEndPoint.Parse("127.0.0.1:5000"));
commandBus.Start();
for (var i = 1; i <= 5; i++)
{
for (var j = 1; j <= 5; j++)
{
await commandBus.SendAsync(new Command1($"Test{i}"));
}
}
Thread.Sleep(1000);
commandBus.Shutdown();
Thread.Sleep(10000);
consumer.Shutdown();
}
private static Socket ConnectSocket(string server, int port)
{
IPEndPoint ipe = IPEndPoint.Parse($"{server}:{port}");
var socket = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ipe);
return(socket);
}
public async Task SetupRaw()
{
var endpoint = IPEndPoint.Parse("127.0.0.1:5432");
this.RawDB = await PgDB.OpenAsync(endpoint, "postgres", "Master1234", "postgres");
this.RawQuery = $"SELECT generate_series(1, {this.NumRows})";
}
private void StartTcpServer()
{
var configuration = configurationProvider.GetConfiguration();
IPEndPoint endpoint = IPEndPoint.Parse(configuration.WorldClusterEndpoint);
tcpServer.Start(endpoint, 10);
logger.Debug("Tcp server has been started");
}
public Program(string serverUri)
{
_cancellationTokenSource = new CancellationTokenSource();
var endPoint = IPEndPoint.Parse(serverUri);
_ip = endPoint.Address.ToString();
_port = endPoint.Port;
}
static void ParseShouldSucceed(string text)
{
Assert.IsTrue(IPv6EndPoint.TryParse(text, out IPv6EndPoint actual));
IPEndPoint expected = IPEndPoint.Parse(text);
Assert.AreEqual(expected, actual);
Assert.AreEqual(expected.ToString(), actual.ToString());
}
public void Values_can_be_correctly_converted_to_ipendpoint_without_the_parser_specifying_a_custom_converter()
{
var option = new Option <IPEndPoint>("-us");
var value = option.Parse("-us 1.2.3.4:56").GetValueForOption(option);
value.Should().Be(IPEndPoint.Parse("1.2.3.4:56"));
}
public async Task StartAsync()
{
var endPoint = IPEndPoint.Parse("0.0.0.0:42151");
_tcpListener = new TcpListener(endPoint);
_tcpListener.Start();
await ConnectionWaitAsync();
}
