public TcpClient Pop()
{
TcpClient result;
if (!mPools.TryPop(out result))
{
int value = System.Threading.Interlocked.Increment(ref mConnections);
if (value > mMaxConnections)
{
System.Threading.Interlocked.Decrement(ref mConnections);
throw new Exception("Unable to reach HTTP request, exceeding maximum number of connections");
}
var packet = new HttpClientPacket();
result = SocketFactory.CreateClient <TcpClient>(packet, Host, Port);
packet.Client = result;
result.Connected = c => { c.Socket.NoDelay = true; };
result.Connect();
result.Socket.SendTimeout = TimeOut;
result.Socket.ReceiveTimeout = TimeOut;
}
else
{
var value = System.Threading.Interlocked.Decrement(ref mPoolConnectins);
}
return(result);
}
static void Main(string[] args)
{
DefaultClientPacket packet = new DefaultClientPacket();
packet.Register(typeof(Employee).Assembly);
TcpClient client = SocketFactory.CreateClient <TcpClient>(packet, "127.0.0.1", 9090);
//TcpClient client = SocketFactory.CreateClient<TcpClient>(packet, "127.0.0.1", 9090,"localhost");
while (true)
{
Console.Write("enter get employee quantity:");
string line = Console.ReadLine();
int quantity;
if (int.TryParse(line, out quantity))
{
SearchEmployee search = new SearchEmployee();
search.Quantity = quantity;
client.SendMessage(search);
var result = client.ReadMessage <IList <Employee> >();
foreach (Employee item in result)
{
Console.WriteLine("\t{0} {1}", item.FirstName, item.LastName);
}
}
else
{
Console.WriteLine("input not a number!");
}
}
}
public void Start()
{
client = SocketFactory.CreateClient <TcpClient>("127.0.0.1", 9291);
//SSL
//AsyncTcpClient client = SocketFactory.CreateSslClient<AsyncTcpClient>("127.0.0.1", 9090, "serviceName");
/*
* client.ClientError = (o, e) =>
* {
* Console.WriteLine("client error {0}@{1}", e.Message, e.Error);
* };
* client.DataReceive = (o, e) =>
* {
* Console.WriteLine(e.Stream.ToPipeStream().ReadToEnd());
* };
* client.Disconnected = (IClient c) =>
* {
* Console.WriteLine("Disconnected");
* };*/
client.Connected = (IClient c) =>
{
Console.WriteLine("Connected");
};
//Console.Read();
}
public void Connect()
{
if (IsConnected)
{
return;
}
lock (mLockConnect)
{
if (IsConnected)
{
return;
}
mWScompletionSource = new TaskCompletionSource <bool>();
if (mNetClient == null)
{
string protocol = Host.Scheme.ToLower();
if (!(protocol == "ws" || protocol == "wss"))
{
OnConnectResponse(new BXException("protocol error! host must [ws|wss]//host:port"), null);
mWScompletionSource.Task.Wait();
}
WSPacket wSPacket = new WSPacket
{
WSClient = this
};
if (Host.Scheme.ToLower() == "wss")
{
mNetClient = SocketFactory.CreateSslClient <AsyncTcpClient>(wSPacket, Host.Host, Host.Port, SSLAuthenticateName);
mNetClient.CertificateValidationCallback = CertificateValidationCallback;
}
else
{
mNetClient = SocketFactory.CreateClient <AsyncTcpClient>(wSPacket, Host.Host, Host.Port);
}
mNetClient.LittleEndian = false;
mNetClient.PacketReceive = OnPacketCompleted;
mNetClient.ClientError = OnClientError;
}
mDataFrames = new System.Collections.Concurrent.ConcurrentQueue <object>();
bool isNew;
if (mNetClient.Connect(out isNew))
{
OnWriteConnect();
}
else
{
OnConnectResponse(mNetClient.LastError, null);
}
mWScompletionSource.Task.Wait(5000);
if (!OnWSConnected)
{
throw new TimeoutException($"Connect {Host} websocket server timeout!");
}
}
}
static void Main(string[] args)
{
TcpClient client = SocketFactory.CreateClient <TcpClient, StringPacket>("127.0.0.1", 9090);
while (true)
{
Console.Write("Enter Name:");
var line = Console.ReadLine();
client.SendMessage(line);
var result = client.ReceiveMessage <string>();
Console.WriteLine($"{DateTime.Now} {result}");
}
}
public AwaiterClient(string host, int port, IClientPacket packet, string sslServiceName = null)
{
if (sslServiceName == null)
{
mClient = SocketFactory.CreateClient <AsyncTcpClient>(packet, host, port);
}
else
{
mClient = SocketFactory.CreateSslClient <AsyncTcpClient>(packet, host, port, sslServiceName);
}
mClient.ClientError = OnError;
mClient.PacketReceive = OnPacketReceive;
}
private void Connect()
{
if (IsConnected)
{
return;
}
lock (mLockConnect)
{
if (IsConnected)
{
return;
}
mWScompletionSource = new TaskCompletionSource <bool>();
if (mNetClient == null)
{
string protocol = UriHost.Scheme.ToLower();
if (!(protocol == "ws" || protocol == "wss"))
{
OnConnectResponse(new BXException("protocol error! host must [ws|wss]//host:port"), null);
mWScompletionSource.Task.Wait();
}
WSPacket wSPacket = new WSPacket
{
WSClient = this
};
if (UriHost.Scheme.ToLower() == "wss")
{
mNetClient = SocketFactory.CreateSslClient <AsyncTcpClient>(wSPacket, UriHost.Host, UriHost.Port, SSLAuthenticateName);
}
else
{
mNetClient = SocketFactory.CreateClient <AsyncTcpClient>(wSPacket, UriHost.Host, UriHost.Port);
}
mNetClient.LittleEndian = false;
mNetClient.PacketReceive = OnPacketCompleted;
mNetClient.ClientError = OnClientError;
}
mDataFrames = new System.Collections.Concurrent.ConcurrentQueue <AgentDataFrame>();
bool isnew;
if (mNetClient.Connect(out isnew))
{
OnWriteConnect();
}
else
{
OnConnectResponse(mNetClient.LastError, null);
}
mWScompletionSource.Task.Wait();
}
}
/// <summary>
/// Connect to canal server.
/// </summary>
/// <returns></returns>
public async Task ConnectAsync()
{
ValidateState(ConnectionState.Closed, nameof(ConnectAsync));
_client = SocketFactory.CreateClient <TcpClient>(_options.Host, _options.Port);
var p = await _client.ReadPacketAsync();
// _client.Socket.ReceiveTimeout = _options.SoTimeout;
//Handshake
ValidatePackageType(p, PacketType.Handshake, 1);
var handshake = Handshake.Parser.ParseFrom(p.Body);
var seed = handshake.Seeds;
var newPassword = _options.Password;
if (_options.Password != null)
{
// encode password
newPassword = SecurityUtil.ByteArrayToHexString(SecurityUtil.Scramble411(Encoding.UTF8.GetBytes(_options.Password), seed.ToByteArray()));
}
//Auth
var data = new ClientAuth()
{
Username = _options.UserName,
Password = ByteString.CopyFromUtf8(newPassword ?? ""),
NetReadTimeout = _options.IdleTimeout,
NetWriteTimeout = _options.IdleTimeout
};
var packet = new Packet()
{
Type = PacketType.Clientauthentication,
Body = data.ToByteString()
}.ToByteArray();
//Send auth data
await _client.WritePacketAsync(packet);
p = await _client.ReadPacketAsync();
//Validate auth ack packet
p.ValidateAck();
//Set state
SetConnectionState(ConnectionState.Connected);
_logger.LogInformation($"Connect to canal server [{_options.Host}:{_options.Port}] success.");
}
static void Main(string[] args)
{
TcpClient client = SocketFactory.CreateClient <TcpClient>("127.0.0.1", 9090);
client.LocalEndPoint = new System.Net.IPEndPoint(IPAddress.Any, 9022);
while (true)
{
Console.Write("Enter Name:");
var line = Console.ReadLine();
client.Stream.ToPipeStream().WriteLine(line);
client.Stream.Flush();
var reader = client.Receive();
line = reader.ReadLine();
Console.WriteLine($"{DateTime.Now} {line}");
}
}
/// <summary>
/// 检查期间就开启服务
/// </summary>
Task IZeroDiscover.Discovery()
{
if (TcpOption.Instance.Client == null || TcpOption.Instance.Client.Address.IsBlank() ||
TcpOption.Instance.Client.Port <= 1024 || TcpOption.Instance.Client.Port >= short.MaxValue)
{
return(Task.CompletedTask);
}
client = SocketFactory.CreateClient <AsyncTcpClient>(TcpOption.Instance.Client.Address, TcpOption.Instance.Client.Port);
client.DataReceive = EventClientReceive;
client.ClientError = EventClientError;
client.Disconnected = Disconnected;
client.Connected = Connected;
client.Connect(out _);
DoStart();
RecordLog(LogLevel.Information, $"{Name}已开启");
return(Task.CompletedTask);
}
static void Main(string[] args)
{
TcpClient client = SocketFactory.CreateClient <TcpClient>("127.0.0.1", 9090);
//TcpClient client = SocketFactory.CreateSslClient<TcpClient>("127.0.0.1", 9090, "localhost");
while (true)
{
Console.Write("Enter Name:");
var line = Console.ReadLine();
client.Stream.ToPipeStream().WriteLine(line);
client.Stream.Flush();
var reader = client.Receive();
line = reader.ToPipeStream().ReadLine();
Console.WriteLine(line);
}
Console.WriteLine("Hello World!");
}
/// <summary>
/// 将数据绘制到UI界面
/// </summary>
/// <param name="Context"></param>
internal static void OpenUI(this PartialContext Context)
{
string[] IP = UIHost.Split(":");
TcpClient Client;
if (Clients.ContainsKey(UIHost))
{
Client = Clients[UIHost];
}
else
{
Client = SocketFactory.CreateClient <TcpClient>(IP[0], int.Parse(IP[1]));
Clients.Add(UIHost, Client);
}
Client.LocalEndPoint = new IPEndPoint(IPAddress.Any, 9373);
Client.Stream.ToPipeStream().WriteLine(Context.ToJson());
Client.Stream.Flush();
}
static async Task Main(string[] args)
{
mServer = BeetleX.SocketFactory.CreateTcpServer <Program>();
mServer.Options.DefaultListen.Host = mHost;
mServer.Options.DefaultListen.Port = 9090;
mServer.Open();
mClient = SocketFactory.CreateClient <AsyncTcpClient>(mHost, 9090);
mClient.DataReceive = (c, e) =>
{
if (e.Stream.ToPipeStream().TryReadLine(out string line))
{
Console.WriteLine("receive:" + line);
Enter();
}
};
Enter();
await Task.Delay(-1);
}
private Task ConnectServer()
{
_connecTask = Task.Run(() =>
{
var ip = tbIP.Text;
var port = tbPort.Text.ToInt();
var con = tbConCount.Text.ToInt();
for (int i = 0; i < con; i++)
{
if (!_loopConStatus)
{
break;
}
AsyncTcpClient client = SocketFactory.CreateClient <AsyncTcpClient>(ip, port);
client.ClientError = (o, e) =>
{
ControlIncrement(lbErrorCount);
ControlAssign(lbErrorMsg, e.Message);
};
client.Receive = (o, e) =>
{
string data = e.Stream.ToPipeStream().ReadToEnd();
ControlIncrement(lbReceiveDataCount);
};
client.Connected = (c) =>
{
ControlIncrement(lbClientCount);
_clients.Add(client);
};
client.Connect();
}
ControlDelegate(btnPause, () => { if (!btnStart.Enabled)
{
btnPause.Enabled = true;
}
});
ControlDelegate(btnPause, () => { btnStop.Enabled = true; });
});
return(_connecTask);
}
static void Main(string[] args)
{
TcpClient client = SocketFactory.CreateClient <TcpClient, Messages.MsgpackClientPacket>("127.0.0.1", 9090);
while (true)
{
Messages.Register register = new Messages.Register();
Console.Write("Enter Name:");
register.Name = Console.ReadLine();
Console.Write("Enter Email:");
register.EMail = Console.ReadLine();
Console.Write("Enter City:");
register.City = Console.ReadLine();
Console.Write("Enter Password:"******"{result.Name} {result.EMail} {result.City} {result.DateTime}");
}
}
public void Start()
{
AsyncTcpClient client = SocketFactory.CreateClient <AsyncTcpClient>("127.0.0.1", 9091);
//SSL
//AsyncTcpClient client = SocketFactory.CreateSslClient<AsyncTcpClient>("127.0.0.1", 9090, "serviceName");
client.ClientError = (o, e) =>
{
Console.WriteLine("client error {0}@{1}", e.Message, e.Error);
};
client.DataReceive = (o, e) =>
{
Console.WriteLine(e.Stream.ToPipeStream().ReadLine());
};
var pipestream = client.Stream.ToPipeStream();
pipestream.WriteLine("hello henry");
client.Stream.Flush();
//Console.Read();
}
private HttpClientHandler Create()
{
var packet = new HttpClientPacket();
AsyncTcpClient client;
if (SSL)
{
client = SocketFactory.CreateSslClient <AsyncTcpClient>(packet, Host, Port, Host);
if (CertificateValidationCallback != null)
{
client.CertificateValidationCallback = CertificateValidationCallback;
}
else
{
client.CertificateValidationCallback = (o, e, d, f) => true;
}
}
else
{
client = SocketFactory.CreateClient <AsyncTcpClient>(packet, Host, Port);
}
//if (this.SslProtocols != null)
// client.SslProtocols = this.SslProtocols;
packet.Client = client;
client.Connected = c =>
{
c.Socket.NoDelay = true;
c.Socket.ReceiveTimeout = TimeOut;
c.Socket.SendTimeout = TimeOut;
};
bool newconn;
client.Connect(out newconn);
var result = new HttpClientHandler();
result.Using = false;
result.Client = client;
lock (Clients)
Clients.Add(result);
return(result);
}
static void Main(string[] args)
{
AsyncTcpClient client = SocketFactory.CreateClient <AsyncTcpClient>("127.0.0.1", 9090);
//AsyncTcpClient client = SocketFactory.CreateSslClient<AsyncTcpClient>("127.0.0.1", 9090, "localhost");
client.ClientError = (c, e) =>
{
Write(string.Format("client error {0} {1}\r\n", e.Error, e.Message));
};
client.DataReceive = (o, e) =>
{
string line = e.Stream.ToPipeStream().ReadLine();
Cmd cmd = ChatParse.Parse(line);
Console.WriteLine(cmd.Text);
};
while (true)
{
Write("login enter you name:");
string line = Console.ReadLine();
string cmd = ChatParse.CreateCommand(CmdType.LOGIN, line);
client.Connect();
client.Stream.ToPipeStream().WriteLine(cmd);
client.Stream.Flush();
while (true)
{
line = Console.ReadLine();
if (line == "quit")
{
client.DisConnect();
break;
}
cmd = ChatParse.CreateCommand(CmdType.SPEAK, line);
client.Stream.ToPipeStream().WriteLine(cmd);
client.Stream.Flush();
}
}
}
/// <summary>
/// 初始化内部通信
/// </summary>
/// <param name="Ip"></param>
/// <param name="Port"></param>
/// <param name="MiddleData"></param>
protected virtual void InitInternalSocket(string Ip, int Port, SocketMiddleData MiddleData)
{
if (CallHandle == null)
{
CallHandle = new CallHandle();
}
AsyncTcpClient ClientAsnyc = SocketFactory.CreateClient <AsyncTcpClient, SocketPacket>(Ip, Port);
if (!ClientPath.IsNullOrEmpty() && ClientPort.HasValue)
{
ClientAsnyc.LocalEndPoint = new IPEndPoint(IPAddress.Parse(ClientPath), ClientPort.Value);
}
ClientAsnyc.Connect(out bool Connect);
Call.SocketClient = ClientAsnyc;
ClientAsnyc.PacketReceive = (Client, Data) =>
{
DependencyCondition Instance = DependencyCondition.Instance;
if (Instance.ExecuteIsCall(Data) != SendTypeEnum.CallBack)
{
var MiddleData = Instance.ExecuteMapper(Data);
if (Client.IsConnected)
{
Call.CallBackHandler(MiddleData, CallHandle);
}
}
else
{
Instance.ExecuteCallData(Data);
}
};
ClientAsnyc.ClientError = (Client, Error) =>
{
DependencyError.Instance.ExecuteRecordLog(Error);
};
if (MiddleData.SendType == SendTypeEnum.Init)
{
ClientAsnyc.Send(MiddleData.ToJson());
}
}
static void Main(string[] args)
{
AsyncTcpClient client = SocketFactory.CreateClient <AsyncTcpClient>("127.0.0.1", 9090);
client.DataReceive = (o, e) =>
{
var pipestream = e.Stream.ToPipeStream();
if (pipestream.TryReadLine(out string line))
{
Console.WriteLine(line);
}
};
while (true)
{
Console.Write("Enter Name:");
BytesHandler line = Console.ReadLine() + "\r\n";
client.Send(line);
if (!client.IsConnected)
{
Console.WriteLine(client.LastError.Message);
}
}
}
}
private void Init()
{
client = SocketFactory.CreateClient <AsyncTcpClient>(host, 8800);
client.DataReceive = (o, args) =>
{
string line = args.Stream.ToPipeStream().ReadLine();
line = ChatModel.Util.StringUtil.GetGBString(line);
Console.WriteLine(line);
CmdInfo info = JsonSerializer.Deserialize <CmdInfo>(line);
switch (info.Type)
{
case CmdType.Error:
Console.WriteLine(info.GetDataRowText());
break;
case CmdType.Login:
user = info.As <User>();
Console.WriteLine($"欢迎[{user.Name}]登录系统");
break;
case CmdType.SendMsg:
ReceiveMsgInfo receiveMsgInfo = info.As <ReceiveMsgInfo>();
if (receiveMsgInfo != null)
{
Console.WriteLine($"[{receiveMsgInfo.From.Name}]:[{receiveMsgInfo.Msg}]");
}
break;
}
};
client.Connected += (c) =>
{
Console.WriteLine("已经连接到服务器");
};
client.Connect();
}
static void Main(string[] args)
{
Messages.ClientPacket packet = new Messages.ClientPacket();
packet.Register(typeof(Employee).Assembly);
TcpClient client = SocketFactory.CreateClient <TcpClient>(packet, "127.0.0.1", 9090);
//TcpClient client = SocketFactory.CreateClient<TcpClient>(packet, "127.0.0.1", 9090, "localhost");
while (true)
{
Console.Write("select search category 1.customer 2.employee :");
string line = Console.ReadLine();
int category;
if (int.TryParse(line, out category))
{
if (category == 1)
{
Console.Write("enter get customer quantity:");
line = Console.ReadLine();
int quantity;
if (int.TryParse(line, out quantity))
{
SearchCustomer search = new SearchCustomer();
search.Quantity = quantity;
client.SendMessage(search);
var result = client.ReceiveMessage <IList <Customer> >();
foreach (Customer item in result)
{
Console.WriteLine("\t{0}", item.CompanyName);
}
}
else
{
Console.WriteLine("input not a number!");
}
}
else if (category == 2)
{
Console.Write("enter get employee quantity:");
line = Console.ReadLine();
int quantity;
if (int.TryParse(line, out quantity))
{
SearchEmployee search = new SearchEmployee();
search.Quantity = quantity;
client.SendMessage(search);
var result = client.ReceiveMessage <IList <Employee> >();
foreach (Employee item in result)
{
Console.WriteLine("\t{0} {1}", item.FirstName, item.LastName);
}
}
else
{
Console.WriteLine("input not a number!");
}
}
else
{
Console.WriteLine("input category error!");
}
}
else
{
Console.WriteLine("input not a number!");
}
}
}
private static void InitClient()
{
_client = SocketFactory.CreateClient <TcpClient>(Settings.IpAddress, Settings.Port);
}
public HttpClient Pop(bool recursion = false)
{
HttpClient result;
if (!mPools.TryDequeue(out result))
{
int value = System.Threading.Interlocked.Increment(ref mConnections);
if (value > MaxConnections)
{
System.Threading.Interlocked.Decrement(ref mConnections);
if (recursion)
{
throw new Exception($"Unable to reach {Host}:{Port} HTTP request, exceeding maximum number of connections");
}
else
{
for (int i = 0; i < Clients.Count; i++)
{
HttpClient httpclient = Clients[i];
if (httpclient.IsTimeout && httpclient.Using)
{
Task.Run(() =>
{
try
{
httpclient.RequestCommpletionSource.Error(new TimeoutException($"{Host}:{Port} request timeout!"));
}
finally
{
httpclient.Client.DisConnect();
}
});
}
}
System.Threading.Thread.Sleep(50);
return(Pop(true));
}
}
var packet = new HttpClientPacket();
AsyncTcpClient client;
if (SSL)
{
client = SocketFactory.CreateSslClient <AsyncTcpClient>(packet, Host, Port, Host);
client.CertificateValidationCallback = (o, e, d, f) => true;
}
else
{
client = SocketFactory.CreateClient <AsyncTcpClient>(packet, Host, Port);
client.CertificateValidationCallback = (o, e, d, f) => true;
}
if (this.SslProtocols != null)
{
client.SslProtocols = this.SslProtocols;
}
packet.Client = client;
client.Connected = c =>
{
c.Socket.NoDelay = true;
c.Socket.ReceiveTimeout = TimeOut;
c.Socket.SendTimeout = TimeOut;
};
result = new HttpClient();
result.Client = client;
result.Node = new LinkedListNode <HttpClient>(result);
Clients.Add(result);
}
result.Using = true;
result.TimeOut = TimeOut;
return(result);
}
public HttpClient Pop(bool recursion = false)
{
HttpClient result;
if (!mPools.TryDequeue(out result))
{
int value = System.Threading.Interlocked.Increment(ref mConnections);
if (value > MaxConnections)
{
System.Threading.Interlocked.Decrement(ref mConnections);
if (recursion)
{
throw new Exception($"Unable to reach {Host}:{Port} HTTP request, exceeding maximum number of connections");
}
else
{
for (int i = 0; i < Clients.Count; i++)
{
HttpClient client = Clients[i];
if (client.IsTimeout && client.Using)
{
Task.Run(() =>
{
try
{
client.RequestCommpletionSource.Error(new TimeoutException($"{Host}:{Port} request timeout!"));
}
finally
{
client.Client.DisConnect();
}
});
}
}
System.Threading.Thread.Sleep(50);
return(Pop(true));
}
}
var packet = new HttpClientPacket();
if (Async)
{
AsyncTcpClient client;
if (SSL)
{
client = SocketFactory.CreateSslClient <AsyncTcpClient>(packet, Host, Port, Host);
}
else
{
client = SocketFactory.CreateClient <AsyncTcpClient>(packet, Host, Port);
}
packet.Client = client;
client.Connected = c =>
{
c.Socket.NoDelay = true;
c.Socket.ReceiveTimeout = TimeOut;
c.Socket.SendTimeout = TimeOut;
};
result = new HttpClient();
result.Client = client;
result.Node = new LinkedListNode <HttpClient>(result);
Clients.Add(result);
}
else
{
TcpClient client;
if (SSL)
{
client = SocketFactory.CreateSslClient <TcpClient>(packet, Host, Port, Host);
}
else
{
client = SocketFactory.CreateClient <TcpClient>(packet, Host, Port);
}
packet.Client = client;
client.Connected = c =>
{
c.Socket.NoDelay = true;
c.Socket.ReceiveTimeout = TimeOut;
c.Socket.SendTimeout = TimeOut;
};
result = new HttpClient();
result.Client = client;
result.Node = new LinkedListNode <HttpClient>(result);
Clients.Add(result);
}
}
result.Using = true;
result.TimeOut = BeetleX.TimeWatch.GetElapsedMilliseconds() + TimeOut * 1000;
return(result);
}