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); }