public async Task <IActionResult> List()
{
if (!await _client.ConnectAsync(new IPEndPoint(_address, _serverPort)))
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Failed to connect to the server."));
}
await _client.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Connect} {ClientType.Short.ToString()}{Package.Terminator}"));
while (true)
{
var p = await _client.ReceiveAsync();
if (p == null)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Connection dropped."));
}
switch (p.Key)
{
case CommandKey.Connected:
await _client.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.ListClient}{Package.Terminator}"));
break;
default:
var clients = JsonConvert.DeserializeObject <List <ClientInfo> >(p.Content).OrderByDescending(n => n.ConnectTime);
await _client.CloseAsync();
return(Ok(clients));
}
}
}
public override async ValueTask ConnectAsync()
{
_cts = new CancellationTokenSource();
if (_client == null)
{
Func <TransportContext> getCtx = () => _context;
_client = new EasyClient <ReceivedPackage>(ServiceProvider.CreateInstance <ReceivedPackageFilter>(getCtx), new ChannelOptions()
{
MaxPackageLength = 1024 * 1024 * 1024
});
}
_client.Closed += async(o, e) =>
{
await DisconnectAsync();
};
if (await _client.ConnectAsync(new IPEndPoint(IPAddress.Parse(ConnectionAddress.IPAddress), ConnectionAddress.Port)))
{
IsConnected = true;
DoReceive();
}
else
{
await DisconnectAsync();
}
}
public override async Task ConnectAsync()
{
_cancellationTokenSource = new CancellationTokenSource();
if (_client == null)
{
_client = new EasyClient <ReceivedPackage>(new ReceivedPackageFilter(GetContext));
}
var connectSuccess = await _client.ConnectAsync(new IPEndPoint(IPAddress.Parse(ConnectionAddress.IPAddress), ConnectionAddress.Port));
if (connectSuccess)
{
DoReceive();
}
}
static async Task Main(string[] args)
{
client = new EasyClient <TextPackageInfo>(new MyPackageFilter()).AsClient();
if (!await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 4040)))
{
Console.WriteLine("Failed to connect the target server.");
return;
}
//client.PackageHandler += async (s, p) =>
//{
// Console.WriteLine(p.Text);
// await Task.CompletedTask;
//};
//client.StartReceive();
//var hdn = Task.Run(Receive);
//hdn.Start();
await client.SendAsync(Encoding.UTF8.GetBytes("Test" + "\r\n"));
//await client.SendAsync(Encoding.UTF8.GetBytes("Test" + "\r\n"));
//await Task.Delay(5000);
//var p = await client.ReceiveAsync();
//Console.WriteLine(p.Text);
await Task.Delay(5000);
while (true)
{
var p = await client.ReceiveAsync();
if (p == null)
{
break;
}
Console.WriteLine("接收到的数据:" + p.Text);
}
//while (true)
//{
// var p = await client.ReceiveAsync();
// Console.WriteLine("接收信息:" + p.Text?.ToString());
//}
}
/// <summary>
/// 连接
/// </summary>
/// <returns></returns>
public async Task ConnectAsync()
{
var client = new EasyClient <IJTTPackageInfo>(Filter);
client.PackageHandler += PackageHandler;
client.Closed += Closed;
EasyClient = client.AsClient();
try
{
var connected = await EasyClient.ConnectAsync(
new IPEndPoint(
IPAddress.Parse(Config.ServerHost),
Config.ServerPort),
CancellationToken.None);
if (connected)
{
Logger.Log(
NLog.LogLevel.Trace,
LogType.系统跟踪,
$"已连接服务器, " +
$"\r\t\nServer: {Config.ServerHost}:{Config.ServerPort}.");
StartReceive();
}
else
{
Logger.Log(
NLog.LogLevel.Trace,
LogType.系统跟踪,
$"连接服务器失败, " +
$"\r\t\nServer: {Config.ServerHost}:{Config.ServerPort}.");
}
}
catch (Exception ex)
{
Logger.Log(
NLog.LogLevel.Error,
LogType.系统异常,
$"连接服务器时发生错误, " +
$"\r\t\nServer: {Config.ServerHost}:{Config.ServerPort}.",
null,
ex);
}
}
/// <summary>Connect to server
/// </summary>
public async ValueTask ConnectAsync()
{
if (_isConnected)
{
_logger.LogWarning("Socket client is connected , don't connect again !");
return;
}
try
{
_easyClient = new EasyClient <Packet>(new PacketFilter(9));
await _easyClient.ConnectAsync(_setting.ServerEndPoint);
_isConnected = true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Socket client to server '{0}' fail!", _setting.ServerEndPoint.ToStringAddress());
_isConnected = false;
}
}
private async Task InitTcp()
{
var options = new ChannelOptions
{
Logger = NullLogger.Instance,
ReadAsDemand = true
};
_client = new EasyClient <TextPackageInfo>(new LinePipelineFilter(), options).AsClient();
var connected = await _client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 8888));
var connectPackage = new MessagePackage <TextMessageModel>()
{
OpCode = OpCode.Connect,
MessageType = MessageType.TextMessage,
Message = new TextMessageModel()
{
LocalName = TbUserName.Text,
RemoteName = "Server"
}
};
await _client.SendAsync(
new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(connectPackage.ToString())));
while (true)
{
var receivePackage =
JsonConvert.DeserializeObject <MessagePackage <TextMessageModel> >((await _client.ReceiveAsync()).Text);
if (receivePackage.Message == null)
{
continue;
}
switch (receivePackage.OpCode)
{
case OpCode.DisConnect:
MessageBox.Show(receivePackage.Message.TextMessage, receivePackage.Message.LocalName);
TbUserName.IsEnabled = true;
break;
case OpCode.Connect:
LvOnlineList.Children.Clear();
var allItem = new UserItemsControl("All");
allItem.setRoteName = SetRoteName;
LvOnlineList.Children.Add(allItem);
foreach (var userClient in receivePackage.Clients)
{
var childItem = new UserItemsControl(userClient.Username);
childItem.setRoteName = SetRoteName;
LvOnlineList.Children.Add(childItem);
}
TbUserName.IsEnabled = false;
break;
case OpCode.All:
this.LbCurrentChat.Content = receivePackage.Message.LocalName;
WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
{
LocalName = receivePackage.Message.LocalName,
TextMessage = receivePackage.Message.TextMessage
}));
break;
case OpCode.Single:
LbCurrentChat.Content = receivePackage.Message.LocalName;
WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
{
LocalName = receivePackage.Message.LocalName,
TextMessage = receivePackage.Message.TextMessage
}));
break;
}
Scr.ScrollToEnd();
if (connected)
{
BdConnectState.Background = new SolidColorBrush(Colors.LimeGreen);
TbUserName.IsEnabled = false;
}
else
{
BdConnectState.Background = new SolidColorBrush(Colors.OrangeRed);
TbUserName.IsEnabled = true;
break;
}
await Task.Delay(500);
}
//while (true)
//{
// var package = await _client.ReceiveAsync();
// //if(package != null) SpChatArea.Text += "Receive:" + package.Text + Environment.NewLine;
// var data = JsonConvert.DeserializeObject<TextMessageModel>(package.Text);
// if (package != null)
// {
// WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
// {
// LocalName = data.LocalName,
// TextMessage = data.TextMessage
// }));
// }
// await Task.Delay(500);
//}
}
private async void InitTcpConnectAndReceive()
{
var options = new ChannelOptions
{
Logger = NullLogger.Instance,
ReadAsDemand = true
};
_sendTcpClient = new EasyClient <TextPackageInfo>(new LinePipelineFilter(), options).AsClient();
_connected = await _sendTcpClient.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 8888));
var connectPackage = new TcpPackage()
{
OpCode = OpCode.Connect,
LocalName = TbUserName.Text,
RemoteName = "Server",
MessageType = MessageType.Text
};
await _sendTcpClient.SendAsync(
new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(connectPackage.ToString())));
while (true)
{
var receivePackage = TcpPackage.JsonToPackage((await _sendTcpClient.ReceiveAsync()).Text);
if (string.IsNullOrEmpty(receivePackage.Message))
{
continue;
}
switch (receivePackage.OpCode)
{
case OpCode.Connect:
SpOnlineList.Children.Clear();
var allItem = new UserItemsControl("All");
allItem.setRoteName = SetRoteName;
SpOnlineList.Children.Add(allItem);
foreach (var onlineClient in receivePackage.Clients)
{
var childItem = new UserItemsControl(onlineClient.Username);
childItem.setRoteName = SetRoteName;
SpOnlineList.Children.Add(childItem);
}
TbUserName.IsEnabled = false;
BtnConnectServer.IsEnabled = false;
break;
case OpCode.DisConnect:
MessageBox.Show(receivePackage.Message, receivePackage.LocalName);
TbUserName.IsEnabled = true;
break;
case OpCode.All:
case OpCode.Single:
LbChatWith.Content = receivePackage.OpCode == OpCode.All
? receivePackage.RemoteName : receivePackage.LocalName;
switch (receivePackage.MessageType)
{
case MessageType.Text:
ChatArea.Children.Add(new ReceiveControl(receivePackage, null));
break;
case MessageType.Image:
// 建立UDP客户端 直接接收消息
ReceiveImage(receivePackage: receivePackage);
break;
case MessageType.File:
var res = MessageBox.Show("是否接收文件?", "提示", MessageBoxButton.YesNo,
MessageBoxImage.Information);
if (res == MessageBoxResult.Yes)
{
// 发送TCP确认连接消息
// 创建UDP客户端
}
break;
}
break;
case OpCode.Confirm:
switch (receivePackage.MessageType)
{
case MessageType.Image:
var fileName = await SendImage();
await Task.Delay(1000);
await SendImage(fileName, receivePackage);
break;
case MessageType.File:
break;
}
break;
}
Scr.ScrollToEnd();
if (_connected)
{
BdConnectState.Background = new SolidColorBrush(Colors.LimeGreen);
TbUserName.IsEnabled = false;
}
else
{
BdConnectState.Background = new SolidColorBrush(Colors.OrangeRed);
TbUserName.IsEnabled = true;
break;
}
//await Task.Delay(1000);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Background service is started...");
var address = IPAddress.Parse(_config.ServerIp);
if (!await _client.ConnectAsync(new IPEndPoint(address, _config.ServerPort), cancellationToken))
{
_logger.LogError("Failed to connect to the target server.");
}
_client.PackageHandler += async(sender, package) =>
{
switch (package.Key)
{
case CommandKey.Execute:
var command = Command.Parser.ParseFrom(Encoding.UTF8.GetBytes(package.Content));
await Execute(command.OperatorId, command.Content);
break;
case CommandKey.Connected:
_logger.LogInformation("Connected");
break;
case CommandKey.Pong:
var unix = long.Parse(package.Content);
_pongTime = DateTimeOffset.FromUnixTimeMilliseconds(unix).UtcDateTime;
break;
default:
_logger.LogWarning($"Unknown command:{package.Key}");
break;
}
};
_client.StartReceive();
await _client.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Connect} {ClientType.Agent.ToString()}{Package.Terminator}"));
_pingTimer = new Timer(SendPing, null, TimeSpan.Zero, TimeSpan.FromSeconds(_pingIntervalSecond));
_checkPingTimer = new Timer(CheckPong, null, TimeSpan.Zero, TimeSpan.FromSeconds(_checkPingIntervalSecond));
_client.Closed += async(sender, args) =>
{
if (!_shouldReconnect)
{
return;
}
_logger.LogError("Connection disconnect.");
Thread.Sleep(2000);
if (!await _client.ConnectAsync(new IPEndPoint(address, _config.ServerPort), cancellationToken))
{
_logger.LogError("Failed to reconnect to the target server.");
}
else
{
_client.StartReceive();
_logger.LogInformation("Connection reconnect.");
}
};
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Socket Service is starting.");
var address = IPAddress.Parse(_serverIp);
if (!await _client.ConnectAsync(new IPEndPoint(address, _serverPort), cancellationToken))
{
_logger.LogError("Failed to connect to the socket server.");
}
_client.PackageHandler += async(sender, package) =>
{
switch (package.Key)
{
case CommandKey.Connected:
_logger.LogInformation("Connected");
break;
case CommandKey.Output:
var index = package.Content.IndexOf(' ');
var operatorId = package.Content.Substring(0, index);
var content = package.Content.Substring(index + 1, package.Content.Length - index - 1);
await _socketHub.Clients.Groups(operatorId).ReceiveMessage(content + Package.Terminator);
break;
case CommandKey.Pong:
var unix = long.Parse(package.Content);
_pongTime = DateTimeOffset.FromUnixTimeMilliseconds(unix).UtcDateTime;
break;
default:
_logger.LogError($"Unknown command:{package.Key}");
break;
}
};
_client.StartReceive();
await _client.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Connect} {ClientType.Web.ToString()}{Package.Terminator}"));
_pingTimer = new Timer(SendPing, null, TimeSpan.Zero, TimeSpan.FromSeconds(_pingIntervalSecond));
_checkPingTimer = new Timer(CheckPong, null, TimeSpan.Zero, TimeSpan.FromSeconds(_checkPingIntervalSecond));
_client.Closed += async(sender, args) =>
{
if (!_shouldReconnect)
{
return;
}
Thread.Sleep(2000);
if (!await _client.ConnectAsync(new IPEndPoint(address, _serverPort), cancellationToken))
{
_logger.LogError("Failed to connect to the socket server.");
}
else
{
_client.StartReceive();
}
};
}