/// <summary> /// 链接到服务器 /// </summary> public IAwait Connect() { lock (syncRoot) { return(socket.Connect()); } }
public void Connect() { if (IsConnected()) { return; } Close(); try { _socket = new SocketAdapter(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { NoDelay = true, ReceiveTimeout = ReceiveTimeout, SendTimeout = SendTimeout }); _socket.Connect(Host, Port); } catch (Exception ex) { throw new GearmanConnectionException("Could not connect", ex); } if (!_socket.Connected) { throw new GearmanConnectionException("Socket not connected"); } _isDead = false; }
private bool ProcessStartPeerMonitoringMessage(IMessage message, ISocket socket) { var shouldHandle = message.Equals(KinoMessages.StartPeerMonitoring); if (shouldHandle) { var payload = message.GetPayload <StartPeerMonitoringMessage>(); logger.Debug($"Received {typeof(StartPeerMonitoringMessage).Name} for node {payload.SocketIdentity.GetAnyString()}@{payload.Uri}. " + $"HealthUri: {payload.Health.Uri}"); var meta = new ClusterMemberMeta { HealthUri = payload.Health.Uri, HeartBeatInterval = payload.Health.HeartBeatInterval, ScaleOutUri = payload.Uri }; meta = connectedPeerRegistry.FindOrAdd(new ReceiverIdentifier(payload.SocketIdentity), meta); // NOTE: Starting peer monitoring may happen after quite some time after it was first added. // To avoid immediate node disconnection, as being dead, update LastKnownHeartBeat before setting ConnectionEstablished to TRUE. meta.LastKnownHeartBeat = DateTime.UtcNow; meta.ConnectionEstablished = true; StartDeadPeersCheck(meta.HeartBeatInterval); socket.Connect(new Uri(meta.HealthUri)); logger.Debug($"Connected to node {payload.SocketIdentity.GetAnyString()}@{meta.HealthUri} for HeartBeat monitoring."); } return(shouldHandle); }
public static void WrappedConnect(this ISocket socket, EndPoint remoteEP) { var invalidateInStoreProxy = false; try { socket.Connect(remoteEP); } catch (SocketException ex) { if (ex.SocketErrorCode == SocketError.ConnectionReset || ex.SocketErrorCode == SocketError.TimedOut) { invalidateInStoreProxy = true; } throw ex; } catch (Exception ex) when(ex is ProxyException || ex is ProtocolViolationException) { invalidateInStoreProxy = true; throw ex; } finally { if (invalidateInStoreProxy) { socket.InvalidateInStoreProxy(); } } }
private bool ProcessReconnectMessage(IMessage message, ISocket socket) { var shouldHandle = message.Equals(ConsensusMessages.ReconnectClusterMember); if (shouldHandle) { var payload = message.GetPayload <ReconnectClusterMemberMessage>(); var healthInfo = nodeHealthInfo.FirstOrDefault(hi => hi.NodeUri == new Uri(payload.NewUri)); if (healthInfo != null) { healthInfo.UpdateLastReconnectTime(); socket.SafeDisconnect(new Uri(payload.OldUri)); socket.Connect(new Uri(payload.NewUri)); logger.Info($"Reconnected to node from {payload.OldUri} to {payload.NewUri}"); } else { logger.Warn($"{message.Identity.GetAnyString()} came for unknown node: {payload.NewUri}"); } } return(shouldHandle); }
/// <summary> /// Opens the socket connection to the FTP server. /// </summary> private void OpenSocket() { _socket.Connect(hostEndPoint.Address.ToString(), hostEndPoint.Port); string[] response = ReadFromSocket(); if (GetReturnCodeFromResponse(response) != ReturnCodes.ServiceReady) { throw new Exception("Error while connecting to FTP server. Server responded: " + String.Join(" ", response)); } }
public void Simple_handshake_client_closes_connection() { serverDelegate.OnConnectionAction = (server, socket) => { Debug.WriteLine("server OnConnection"); serverSocketDelegate = new SocketDelegate(); serverSocketDelegate.OnEndAction = () => { Debug.WriteLine("serverSocket OnEnd"); socket.End(); }; serverSocketDelegate.OnCloseAction = () => { Debug.WriteLine("serverSocket OnClose"); socket.Dispose(); }; return(serverSocketDelegate); }; schedulerStartedAction = () => { clientSocketDelegate.OnConnectedAction = () => { Debug.WriteLine("client End"); client.End(); }; clientSocketDelegate.OnCloseAction = () => { Debug.WriteLine("client OnClose"); scheduler.Stop(); }; client.Connect(ep); }; RunScheduler(); AssertConnectionAndCleanShutdown(); }
private void btnConnect_Click(object sender, EventArgs e) { if (_socket.IsConnected) { return; } _socket.SetConnection(txtIPAddress.Text, 11000); _socket.Connect(); //SetStatus(_server.IsConnected); }
public void Connect() { lock (this) { if (_socket == null) { _socket = new RawSocket(); _socket.Connect(Endpoint); } } }
public void Load() { //Dimlibs.Instance.Logger.Info("Is chat socket open? " + IsChatOpen()); Dimlibs.Instance.Logger.Info("Chat is initializing"); try { if (!Program.LaunchParameters.ContainsKey("-chat")) { TcpListener listener = new TcpListener(IPAddress.Any, _port); listener.Start(); ThreadPool.QueueUserWorkItem(InitializeChatRelay, listener); } } catch (Exception e) { Console.WriteLine(e); } while (true) { if (_socket != null && _socket.IsConnected()) { break; } } if (Main.netMode == 2) { On.Terraria.Net.NetManager.SendToServer += NetManagerOnSendToServer; _socket = new TcpSocket(); Netplay.SetRemoteIP("127.0.0.1"); _socket.Connect(new Terraria.Net.TcpAddress(Netplay.ServerIP, _port)); connection = new RemoteServer(); connection.Socket = _socket; connection.ReadBuffer = new byte[ushort.MaxValue]; } else { On.Terraria.Net.NetManager.SendToClient += NetManagerOnSendToClient; _socket = new TcpSocket(); Netplay.SetRemoteIP("127.0.0.1"); _socket.Connect(new Terraria.Net.TcpAddress(Netplay.ServerIP, _port)); connection = new RemoteServer(); connection.Socket = _socket; connection.ReadBuffer = new byte[ushort.MaxValue]; } Dimlibs.Instance.Logger.Info("Chat is initialized and ready to go"); }
public void Connect(string ip, int port) { _keys = Ssui.Security.CreateAesKey(); var publicKey = _keys.PublicKey; Task.Factory.StartNew(() => { using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) { writeStream.ShiftRight(publicKey); _socket.Connect(ip, port, writeStream); } }); }
private static void TcpConnectThread(ISocket connectSocket, EndPoint remoteEndpont, Func <ISocket, Exception, Socket> callback) { try { connectSocket.Connect(remoteEndpont); } catch (Exception ex) { callback(null, ex); } callback(connectSocket, null); }
public bool StartMonitor(ref string reStr) { if (this.mySocket != null) { this.mySocket.Disconnect(); } this.mySocket = new STcpClient(); this.mySocket.ReceiveCompleted += ReciveEventHandler; this.mySocket.LostLink += LostLinkEventHandler; return(mySocket.Connect(this.DevIP, this.DevPort, ref reStr)); }
public void Connect(IPEndPoint endpoint) { lock (this) { Endpoint = endpoint; if (_socket == null) { _socket = new RawSocket(); _socket.Connect(endpoint); } } }
public virtual void Connect(CancellationToken token) { Debug.Assert(currentWriteCopier == null); Debug.Assert(inprogressResponse == null); Debug.Assert(readQueue.Count == 0); LogTo.Info($"Connecting node to {name}"); socket.Connect(endpoint, token); mustReconnect = false; IsAlive = true; }
// Use this for initialization private void Start() { Debug.LogError("start"); IPackage iPackage = new Package(); socket = new TcpConnection(iPackage); socket.StateChangeHandler = OnStateChange; socket.Connect("127.0.0.1", 5077); //_register.Regist(100, OnMsg); //socket.DisConnect(); }
/// <summary> /// Send to server request to connect /// </summary> /// <param name="ep">server endpoint</param> /// <returns></returns> public bool BeginConnect(IPEndPoint ep) { try { _client.Connect(ep); } catch { return(false); } var buffer = Message.Handshake; var p = new Packet(buffer); _client.Send(p.Serialize()); return(true); }
/// <summary> /// Connects the socket to the specified port. This is used to connect the python script to Unity. /// </summary> /// <returns>true if connected.</returns> public bool Connect() { try { socket.Connect("localhost", PORT); Debug.Log("Established tcpSocket Connection with Python"); return(true); } catch (Exception e) { Debug.Log(e); } return(false); }
public string LookupDotComDomain(string domainName, int port, string whoisServer, string whoisServerLookupQueryPrefix, int responseBufferSizeInBytes) { Guard.WhenArgument(domainName, "DomainName").IsNullOrEmpty().Throw(); if (domainName.StartsWith(WhoisConstants.ForbiddenDomainStartSymbol)) { throw new ArgumentException("Domain name cannot start with hyphen."); } if (!domainName.ToLower().EndsWith(WhoisConstants.DomainEndPattern)) { throw new ArgumentException("Domain name should be a .com domain."); } var regex = new Regex(WhoisConstants.RegexDomainPattern); // remove ".com" if (!regex.IsMatch(domainName.ToLower().Substring(0, domainName.Length - 4))) { throw new ArgumentException("Domain should only contain letters, numbers or hyphen."); } Guard.WhenArgument(domainName.Length, "DomainName").IsLessThan(WhoisConstants.MinimumDomainNameLength).Throw(); Guard.WhenArgument(domainName.Length, "DomainName").IsGreaterThan(WhoisConstants.MaximumDomainNameLength).Throw(); Guard.WhenArgument(port, "Port").IsLessThan(WhoisConstants.TcpMinPort).Throw(); Guard.WhenArgument(port, "Port").IsGreaterThan(WhoisConstants.TcpMaxPort).Throw(); Guard.WhenArgument(whoisServer, "WhoisServer").IsNullOrEmpty().Throw(); Guard.WhenArgument(whoisServerLookupQueryPrefix, "WhoisServerLookupQueryPrefix").IsNullOrEmpty().Throw(); Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsLessThan(WhoisConstants.MinimumResponseBufferSizeInBytes).Throw(); Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsGreaterThan(WhoisConstants.MaximumResponseBufferSizeInBytes).Throw(); socket.Connect(whoisServer, port); byte[] query = Encoding.ASCII.GetBytes(whoisServerLookupQueryPrefix + domainName + Environment.NewLine); socket.Send(query); byte[] responseBytes = new byte[responseBufferSizeInBytes]; socket.Receive(responseBytes); socket.Dispose(); string humanReadableResponse = Encoding.UTF8.GetString(responseBytes); return(humanReadableResponse); }
public virtual void Connect(CancellationToken token) { Debug.Assert(currentWriteCopier == null); Debug.Assert(inprogressResponse == null); Debug.Assert(readQueue.Count == 0); if (LogDebugEnabled) { log.Debug("Connecting node to " + endpoint); } socket.Connect(endpoint, token); mustReconnect = false; IsAlive = true; }
public void InitSocketManager(ISocketManager socketManager) { Socket = socketManager.Create("http://192.168.1.3:3000/"); Socket.OnConnect = () => { Socket.Emit("shoes2", new { F**k = "Yopu" }); }; Socket.On <Boo>("shoes", a => { }); Socket.On <Boo>("shoes3", a => { }); Socket.Connect(); }
private bool ForwardMessageAway(ExternalRouteLookupRequest lookupRequest, Message message, ISocket scaleOutBackend) { var routes = message.Distribution == DistributionPattern.Broadcast && !MessageCameFromLocalActor(message) ? Enumerable.Empty <PeerConnection>() : externalRoutingTable.FindRoutes(lookupRequest); foreach (var route in routes) { try { if (!route.Connected) { scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true); route.Connected = true; clusterServices.GetClusterHealthMonitor() .StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health); } message.SetSocketIdentity(route.Node.SocketIdentity); message.AddHop(); message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress()); message.SignMessage(securityProvider); scaleOutBackend.SendMessage(message); ForwardedToOtherNode(message); } catch (TimeoutException err) { clusterServices.GetClusterHealthMonitor() .ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity)); logger.Error(err); } catch (HostUnreachableException err) { var unregMessage = new UnregisterUnreachableNodeMessage { ReceiverNodeIdentity = route.Node.SocketIdentity }; TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend); logger.Error(err); } } return(routes.Any()); }
// Connect(u32 socket, buffer<nn::socket::sockaddr_in, 0x21, 0x10>) -> (i32 ret, u32 bsd_errno) public ResultCode Connect(ServiceCtx context) { int socketFd = context.RequestData.ReadInt32(); (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21(); LinuxError errno = LinuxError.EBADF; ISocket socket = _context.RetrieveSocket(socketFd); if (socket != null) { IPEndPoint endPoint = context.Memory.Read <BsdSockAddr>(bufferPosition).ToIPEndPoint(); errno = socket.Connect(endPoint); } return(WriteBsdResult(context, 0, errno)); }
public IConnection Connect(EndPoint endPoint) { if (active) { throw new InvalidOperationException("Peer is already active"); } active = true; socket.Connect(endPoint); Connection connection = CreateNewConnection(endPoint); connection.State = ConnectionState.Connecting; // update now to send connectRequest command connection.Update(); return(connection); }
private bool SendMessageAway(IEnumerable <PeerConnection> routes, Message message, ISocket scaleOutBackend) { foreach (var route in routes) { try { if (!route.Connected) { scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true); route.Connected = true; clusterServices.GetClusterHealthMonitor() .StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health); } message.SetSocketIdentity(route.Node.SocketIdentity); message.AddHop(); message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress()); message.SignMessage(securityProvider); scaleOutBackend.SendMessage(message); ForwardedToOtherNode(message); } catch (TimeoutException err) { clusterServices.GetClusterHealthMonitor() .ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity)); logger.Error(err); } catch (HostUnreachableException err) { var unregMessage = new UnregisterUnreachableNodeMessage { ReceiverNodeIdentity = route.Node.SocketIdentity }; TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend); logger.Error(err); } } return(routes.Any()); }
public IConnection Connect(IEndPoint endPoint) { if (_active) { throw new InvalidOperationException("Peer is already active"); } if (endPoint == null) { throw new ArgumentNullException(nameof(endPoint)); } _active = true; _socket.Connect(endPoint); var connection = CreateNewConnection(endPoint); connection.State = ConnectionState.Connecting; // update now to send connectRequest command connection.Update(); return(connection); }
/// <summary> /// Expect a call of the Connect method and simulate a correct response by the FTP server. /// </summary> /// <param name="mockSocket">The fake socket.</param> private void ExpectConnect(ISocket mockSocket) { mockSocket.Connect(TCP_HOST, TCP_PORT); ExpectReceive(mockSocket, "220 This is a fake FTP server"); }
public void Connect() { lock (SyncObject) { if (IsConnected()) return; Close(); try { _socket = new SocketAdapter(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { NoDelay = true, ReceiveTimeout = ReceiveTimeout, SendTimeout = SendTimeout }); _socket.Connect(Host, Port); } catch (Exception ex) { throw new GearmanConnectionException("Could not connect", ex); } if (!_socket.Connected) { throw new GearmanConnectionException("Socket not connected"); } _isDead = false; } }
private static void TcpConnectThread(ISocket connectSocket, EndPoint remoteEndpont, Func<ISocket, Exception, Socket> callback) { try { connectSocket.Connect(remoteEndpont); } catch (Exception ex) { callback(null, ex); } callback(connectSocket, null); }
public Task Connect() => _socket.Connect();
private bool RegisterExternalRoutes(IMessage message, ISocket scaleOutBackend) { var shouldHandle = IsExternalRouteRegistration(message); if (shouldHandle) { var payload = message.GetPayload<RegisterExternalMessageRouteMessage>(); var handlerSocketIdentifier = new SocketIdentifier(payload.SocketIdentity); var uri = new Uri(payload.Uri); foreach (var registration in payload.MessageContracts) { try { var messageHandlerIdentifier = new MessageIdentifier(registration.Version, registration.Identity); externalRoutingTable.AddMessageRoute(messageHandlerIdentifier, handlerSocketIdentifier, uri); scaleOutBackend.Connect(uri); } catch (Exception err) { logger.Error(err); } } } return shouldHandle; }
private void ProxyThis(ISocket instream, ISocket outstream, AutoResetEvent readyToConnect) { Logger.Debug("Starting Proxy from " + instream + " to " + outstream); int read = 1; Closed = false; try { var inBuffer = new byte[_bufferSize]; // listen for incoming connection if (!instream.Connected) { readyToConnect.Set(); Logger.Debug("Listening for incoming connections"); instream.ListenOnce(); Logger.Debug("Connected incoming"); } // connect to outgoing endpoint and start the reverse proxy if (!outstream.Connected) { outstream.Connect(); Logger.Debug("Connected outgoing"); _outRunner.Start(); Logger.Debug("Started Reverse Proxy"); } while (read > 0) { // Read from instream if (read > 0) { try { read = instream.Read(inBuffer, _bufferSize); #if DEBUG // Logger.Debug("Read " + read + " bytes from " + instream); #endif } catch (Exception ex) { Logger.Error("Failed to read data from stream (" + instream + "), closing proxy : " + ex.Message); break; } if (read > 0) { try { outstream.Send(inBuffer, read); #if DEBUG //Logger.Debug("Wrote " + read + " bytes to " + outstream); #endif } catch (Exception ex) { Logger.Error("Failed to send data through stream (" + instream + ") , closing proxy : " + ex.Message); break; } } } else { Logger.Warn("Read no data from (" + instream + "), closing proxy"); } } } catch (Exception ex) { Logger.Error("Thread caught exception while processing : " + ex.Message, ex); } finally { try { instream.Close(); } catch (Exception ex) { Logger.Error("Caught Error closing stream (" + instream + ") : " + ex.Message, ex); } try { outstream.Close(); } catch (Exception ex) { Logger.Error("Caught Error closing stream (" + outstream + ") : " + ex.Message, ex); } } }
private void ProxyThis(ISocket instream, ISocket outstream, AutoResetEvent readyToConnect) { Logger.Debug("Starting Proxy from " + instream + " to " + outstream); int read = 1; Closed = false; try { var inBuffer = new byte[_bufferSize]; // listen for incoming connection if (!instream.Connected) { readyToConnect.Set(); Logger.Debug("Listening for incoming connections"); instream.ListenOnce(); Logger.Debug("Connected incoming"); } // connect to outgoing endpoint and start the reverse proxy if (!outstream.Connected) { outstream.Connect(); Logger.Debug("Connected outgoing"); _outRunner.Start(); Logger.Debug("Started Reverse Proxy"); } while (read > 0) { // Read from instream if (read > 0) { try { read = instream.Read(inBuffer, _bufferSize); #if DEBUG // Logger.Debug("Read " + read + " bytes from " + instream); #endif } catch (Exception ex) { Logger.Error("Failed to read data from stream (" + instream + "), closing proxy : " + ex.Message); break; } if (read > 0) { try { outstream.Send(inBuffer, read); #if DEBUG //Logger.Debug("Wrote " + read + " bytes to " + outstream); #endif } catch (Exception ex) { Logger.Error("Failed to send data through stream (" + instream + ") , closing proxy : " + ex.Message); break; } } } else { Logger.Warn("Read no data from (" + instream + "), closing proxy"); } } } catch (Exception ex) { Logger.Error("Thread caught exception while processing : " + ex.Message, ex); } finally { try { instream.Close(); } catch (Exception ex) { Logger.Error("Caught Error closing stream (" + instream + ") : " + ex.Message, ex); } try { outstream.Close(); } catch (Exception ex) { Logger.Error("Caught Error closing stream (" + outstream + ") : " + ex.Message, ex); } } }
public bool Detect() { try { _socket = CreateSocket(); _working = true; Log("start working"); _socket.Connect(new TcpAddress(IPAddress.Loopback, TShock.Config.ServerPort)); if (_socket.IsConnected()) { Log("connected"); } else { throw new SocketException(ConnectionRefusedCode); } } catch (SocketException ex) { if (ex.ErrorCode == ConnectionRefusedCode) { Log("connection failed"); } Log(ex.ToString()); CloseSocket(); return(true); } try { _socket.AsyncSend(_writeBuffer, 0, _versionStrLength, SendCallback); _socket.AsyncReceive(_readBuffer, 0, _readBuffer.Length, ReceiveCallback); for (var i = 0; i < 3; i++) { if (!_working) { break; } Thread.Sleep(1000); } } catch (Exception ex) { Log("Unhandled exception in socket send & receive"); Log(ex.ToString()); } finally { CloseSocket(); } return(_working || _status); }