private void StartDataClient(Guid id, ITransport transport) { if (this.disposed) { return; } var dataClient = transport.Connect(this.host); dataClient.WriteSessionId(id); var thread = new Thread(new ThreadStart(() => { try { while (!this.disposed) { var data = dataClient.ReadMessage(); var envelope = data.Item1; var message = data.Item2; this.replayStart = envelope.OriginatingTime.Ticks + 1; // for restart if (this.allowSequenceRestart) { // patch sequence ID resents (due to exporter process restart) var sourceId = envelope.SourceId; var sequenceId = envelope.SequenceId; if (!this.lastSequenceIdPerStream.ContainsKey(sourceId)) { this.lastSequenceIdPerStream.Add(sourceId, sequenceId - 1); // tracking new source } var lastSequenceId = this.lastSequenceIdPerStream[sourceId]; if (lastSequenceId >= sequenceId) { sequenceId = lastSequenceId + 1; envelope = new Envelope(envelope.OriginatingTime, envelope.Time, sourceId, sequenceId); } this.lastSequenceIdPerStream[sourceId] = sequenceId; } this.storeWriter.Write(new BufferReader(message), envelope); Trace.WriteLine($"RemoteImporter data written (Stream={envelope.SourceId}, ID={id}, SequenceId={envelope.SequenceId}, Size={message.Length})"); } } catch (Exception ex) { Trace.WriteLine($"RemoteImporter data connection error (Message={ex.Message}, ID={id})"); dataClient.Dispose(); } })) { IsBackground = true }; thread.Start(); this.dataClientThread = thread; }
public void Connect(SocketConnectionParameters parameters) { if (_connection != null) { _connection.Disconnect(); } _connection = _transport.Connect(parameters.IPAddress, parameters.Port); }
public void Start() { if (!_receiverWorker.IsBusy) { _transport.Connect(); _receiverWorker.RunWorkerAsync(); _commandsWorker.RunWorkerAsync(); } }
private ITransport CreateTransport(I2PRouterInfo ri) { ITransport transport = null; try { var pproviders = TransportProtocols .Select(tp => new { Provider = tp, Capability = tp.ContactCapability(ri) }) .Where(tp => tp.Capability != ProtocolCapabilities.None) .GroupBy(tp => tp.Capability) .OrderByDescending(cc => (int)cc.Key); var pprovider = pproviders.FirstOrDefault()?.Random(); if (pprovider == null) { Logging.LogTransport( $"TransportProvider: CreateTransport: No usable address found for {ri.Identity.IdentHash.Id32Short}!"); return(null); } transport = pprovider.Provider.AddSession(ri); Logging.LogTransport($"TransportProvider: Creating new {transport} to {ri.Identity.IdentHash.Id32Short}"); AddTransport(transport); transport.Connect(); var dstore = new DatabaseStoreMessage(RouterContext.Inst.MyRouterInfo); transport.Send(dstore); } catch (Exception ex) { #if LOG_MUCH_TRANSPORT Logging.LogTransport(ex); Logging.LogTransport("TransportProvider: CreateTransport stack trace: " + System.Environment.StackTrace); #else Logging.LogTransport($"TransportProvider: Exception [{ex.GetType()}] " + $"'{ex.Message}' to {ri.Identity.IdentHash.Id32Short}."); #endif if (transport != null) { Remove(transport); } throw; } return(transport); }
private async Task <Scene> GetScene(string sceneId, SceneEndpoint ci) { if (_serverConnection == null) { if (!_transport.IsRunning) { cts = new CancellationTokenSource(); _transport.Start("client", new ConnectionHandler(), cts.Token, null, (ushort)(_maxPeers + 1)); } if (!ci.TokenData.Endpoints.ContainsKey(_transport.Name)) { throw new InvalidOperationException($"No endpoint available on server for transport '{_transport.Name}'"); } _serverConnection = await _transport.Connect(ci.TokenData.Endpoints[_transport.Name]); foreach (var kvp in _metadata) { _serverConnection.Metadata[kvp.Key] = kvp.Value; } await UpdateServerMetadata(); if (ci.TokenData.Version > 0) { StartSyncClock(); } } var parameter = new Stormancer.Dto.SceneInfosRequestDto { Metadata = _serverConnection.Metadata, Token = ci.Token }; var result = await SendSystemRequest <Stormancer.Dto.SceneInfosRequestDto, Stormancer.Dto.SceneInfosDto>((byte)SystemRequestIDTypes.ID_GET_SCENE_INFOS, parameter); if (_serverConnection.GetComponent <ISerializer>() == null) { if (result.SelectedSerializer == null) { throw new InvalidOperationException("No seralizer selected."); } _serverConnection.RegisterComponent(_serializers[result.SelectedSerializer]); _serverConnection.Metadata.Add("serializer", result.SelectedSerializer); } await UpdateServerMetadata(); var scene = new Scene(this._serverConnection, this, _pluginCtx.BuildingSceneResolver, sceneId, ci.Token, result); if (_pluginCtx.SceneCreated != null) { _pluginCtx.SceneCreated(scene); } return(scene); }
private void Connect(object state) { lock (_result) { try { _transport.Connect(_url); } catch (Exception ex) { _transportException = ex; } End(); } }
/// <summary> /// Connects the client to the specified url /// </summary> public void Connect(string url) { // check object state if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } if (_transport == null) { _transport = CreateTransport(); _transport.Connect(url); _url = url; } }
public async Task Connect() { outputThread = new Thread(new ThreadStart(ProcessOutput)); outputThread.Name = "Microcontroller output"; outputThread.IsBackground = true; outputThread.Start(); inputThread = new Thread(new ThreadStart(ProcessInput)); inputThread.Name = "Microcontroller input"; inputThread.IsBackground = true; inputThread.Start(); transport.Connect(); await RemoteReset(); LocalReset(); }
private void MakeBrokerConnection(IBrokerInfo brokerDetail) { try { _stateManager = new AMQStateManager(); _protocolListener = new AMQProtocolListener(this, _stateManager); _protocolListener.AddFrameListener(_stateManager); /* * // Currently there is only one transport option - BlockingSocket. * String assemblyName = "Apache.Qpid.Client.Transport.Socket.Blocking.dll"; * String transportType = "Apache.Qpid.Client.Transport.Socket.Blocking.BlockingSocketTransport"; * * // Load the transport assembly dynamically. * _transport = LoadTransportFromAssembly(brokerDetail.getHost(), brokerDetail.getPort(), assemblyName, transportType); */ _transport = new BlockingSocketTransport(); // Connect. _transport.Connect(brokerDetail, this); _protocolWriter = new ProtocolWriter(_transport.ProtocolWriter, _protocolListener); _protocolSession = new AMQProtocolSession(_transport.ProtocolWriter, _transport, this); _protocolListener.ProtocolSession = _protocolSession; // Now start the connection "handshake". _transport.ProtocolWriter.Write(new ProtocolInitiation()); // Blocks until the connection has been opened. _stateManager.AttainState(AMQState.CONNECTION_OPEN); _failoverPolicy.attainedConnection(); // XXX: Again this should be changed to a suitable notify. _connected = true; } catch (AMQException e) { _lastAMQException = e; throw; // rethrow } }
public void Connect() { // 2 requiered headers + 3 optional var frame = new Frame(5); frame.Type = FrameType.CONNECT; frame.Headers.Add(AcceptVersion.ToKeyValue()); frame.Headers["host"] = Host; if (!string.IsNullOrWhiteSpace(Login)) { frame.Headers["login"] = Login; } if (!string.IsNullOrWhiteSpace(Passcode)) { frame.Headers["passcode"] = Passcode; } frame.Headers["heart-beat"] = string.Format("{0},{1}", OutgoingHeartbeat, IncomingHeartbeat); transport.Connect(); transport.Send(frame.ToString()); }
public void Connect() { try { var state = (StompConnectionState)Interlocked.CompareExchange( ref _state, value: (int)StompConnectionState.Connecting, comparand: (int)StompConnectionState.Disconnected ); switch (state) { case StompConnectionState.Disconnected: // Соединение было разорвано, сейчас состояние - Connecting // Текущий поток должен выполнить подключение OnStateChanged(StompConnectionState.Connecting); _transport = _transportFactory.Create(_brokerUri, this); _transport.Connect(); break; case StompConnectionState.Connecting: // Соединение устанавливается, следует дождаться изменения состояния while (State == StompConnectionState.Connecting) { } break; case StompConnectionState.Disconnecting: throw new StompConnectionException("Unable to connect while disconnecting"); default: return; } } catch (Exception e) { _logger.Error("Error while connecting", e); throw; } }
private void Connect() { if (_transport.State == TransportState.Closed) { m_mutex.Wait(); try { if (_transport.State == TransportState.Closed) { _transport.Connect(); if (_optionsAccessor.Password != null) { var response = Execute(new Request(CommandType.Auth, _optionsAccessor.Password)); VerifyAuthentication(response); } } } finally { m_mutex.Release(); } } }
internal void Add(ITransport transport, TransportCallback connectCallback) { try { // XXX: This should be negotiated as part of the initial handshake. transport.Encryptor = new AESTransportEncryptor(); transports.Add(transport); if (NewTransportAdded != null) { NewTransportAdded(transport); } LoggingService.LogInfo($"Transport {transport} added"); if (transport.Incoming) { if (connectCallback != null) { throw new ArgumentException("You can only specify a ConnectCallback for outoging connections!"); } if (transport.Encryptor != null) { var dh = new DiffieHellmanManaged(); var keyxBytes = new byte[transport.Encryptor.KeyExchangeLength]; transport.Receive(keyxBytes, 0, keyxBytes.Length); keyxBytes = dh.DecryptKeyExchange(keyxBytes); var keyBytes = new byte[transport.Encryptor.KeySize]; var ivBytes = new byte[transport.Encryptor.IvSize]; Array.Copy(keyxBytes, 0, keyBytes, 0, keyBytes.Length); Array.Copy(keyxBytes, keyBytes.Length, ivBytes, 0, ivBytes.Length); keyxBytes = dh.CreateKeyExchange(); transport.Send(keyxBytes, 0, keyxBytes.Length); transport.Encryptor.SetKey(keyBytes, ivBytes); } //Receive connection type, which is a ulong (8 bytes) var responseBuffer = new byte[8]; transport.Receive(responseBuffer, 0, 8); var connectionType = EndianBitConverter.ToUInt64(responseBuffer, 0); // Recieve network ID (64 bytes) responseBuffer = new byte[64]; transport.Receive(responseBuffer, 0, 64); var networkId = EndianBitConverter.ToString(responseBuffer).Replace("-", ""); // Match to one of our known networks! foreach (var network in core.Networks) { if (network.NetworkID == networkId) { transport.Network = network; } } if (transport.Network == null) { throw new Exception($"Unknown network: {networkId}."); } transport.ConnectionType = connectionType; if (connectionType == ConnectionType.NodeConnection) { var connection = new LocalNodeConnection(transport); transport.Operation = connection; transport.Network.AddConnection(connection); connection.Start(); } else if (connectionType == ConnectionType.TransferConnection) { core.FileTransferManager.NewIncomingConnection(transport); } else { throw new Exception($"Unknown connection type: {connectionType}."); } } else { if (connectCallback == null) { throw new ArgumentNullException(nameof(connectCallback)); } connectCallbacks.Add(transport, connectCallback); LoggingService.LogInfo("Transport {0} connecting...", transport); TransportCallback callback = OnConnected; transport.Connect(callback); } } catch (Exception ex) { transport.Disconnect(ex); RaiseTransportError(transport, ex); } }
/// <summary> /// Connects to the registry end point /// </summary> public void Connect(SslProtocols sslProtocols = SslProtocols.Tls) { transport.Connect(sslProtocols); transport.Read(); }
public void Add(ITransport transport, TransportCallback connectCallback) { try { // XXX: This should be negotiated as part of the initial handshake. transport.Encryptor = new AESTransportEncryptor(); transports.Add(transport); NewTransportAdded?.Invoke(this, new TransportEventArgs(transport)); this.loggingService.LogInfo(String.Format("Transport {0} added", transport.ToString())); if (transport.Incoming == true) { if (connectCallback != null) { throw new ArgumentException("You can only specify a ConnectCallback for outoging connections!"); } if (transport.Encryptor != null) { DiffieHellmanManaged dh = new DiffieHellmanManaged(); byte[] keyxBytes = new byte[transport.Encryptor.KeyExchangeLength]; transport.Receive(keyxBytes, 0, keyxBytes.Length); keyxBytes = dh.DecryptKeyExchange(keyxBytes); byte[] keyBytes = new byte[transport.Encryptor.KeySize]; byte[] ivBytes = new byte[transport.Encryptor.IvSize]; Array.Copy(keyxBytes, 0, keyBytes, 0, keyBytes.Length); Array.Copy(keyxBytes, keyBytes.Length, ivBytes, 0, ivBytes.Length); keyxBytes = dh.CreateKeyExchange(); transport.Send(keyxBytes, 0, keyxBytes.Length); transport.Encryptor.SetKey(keyBytes, ivBytes); } //Receive connection type, which is a ulong (8 bytes) byte[] responseBuffer = new byte[8]; transport.Receive(responseBuffer, 0, 8); ulong connectionType = EndianBitConverter.ToUInt64(responseBuffer, 0); // Recieve network ID (64 bytes) responseBuffer = new byte[64]; transport.Receive(responseBuffer, 0, 64); string networkId = EndianBitConverter.ToString(responseBuffer).Replace("-", ""); // Match to one of our known networks! foreach (Network network in Core.Networks) { if (network.NetworkID == networkId) { transport.Network = network; } } if (transport.Network == null) { throw new Exception(String.Format("Unknown network: {0}.", networkId)); } transport.ConnectionType = connectionType; if (connectionType == ConnectionType.NodeConnection) { LocalNodeConnection connection = new LocalNodeConnection(transport); transport.Operation = connection; transport.Network.AddConnection(connection); connection.Start(); } else if (connectionType == ConnectionType.TransferConnection) { this.fileTransferManager.HandleIncomingTransport(transport); } else { throw new Exception(String.Format("Unknown connection type: {0}.", connectionType.ToString())); } } else { if (connectCallback == null) { throw new ArgumentNullException("connectCallback"); } connectCallbacks.Add(transport, connectCallback); this.loggingService.LogInfo("Transport {0} connecting...", transport); TransportCallback callback = new TransportCallback(OnConnected); transport.Connect(callback); } } catch (Exception ex) { transport.Disconnect(ex); RaiseTransportError(transport, ex); } }
/// Make an out going connection to this given host on the given port. /// There is no return value on this call because all returns are done via callback. public void Connect(string host, int port) { _transport.Connect(host, port); }
public void Connect() { transport.Connect(this); }
/// <summary> /// Connects the client to the specified url /// </summary> public void Connect(string url) { // check object state if (_disposed) throw new ObjectDisposedException(GetType().FullName); if (_transport == null) { _transport = CreateTransport(); _transport.Connect(url); _url = url; } }
private void MakeBrokerConnection(IBrokerInfo brokerDetail) { try { _stateManager = new AMQStateManager(); _protocolListener = new AMQProtocolListener(this, _stateManager); _protocolListener.AddFrameListener(_stateManager); /* // Currently there is only one transport option - BlockingSocket. String assemblyName = "Apache.Qpid.Client.Transport.Socket.Blocking.dll"; String transportType = "Apache.Qpid.Client.Transport.Socket.Blocking.BlockingSocketTransport"; // Load the transport assembly dynamically. _transport = LoadTransportFromAssembly(brokerDetail.getHost(), brokerDetail.getPort(), assemblyName, transportType); */ _transport = new BlockingSocketTransport(); // Connect. _transport.Connect(brokerDetail, this); _protocolWriter = new ProtocolWriter(_transport.ProtocolWriter, _protocolListener); _protocolSession = new AMQProtocolSession(_transport.ProtocolWriter, _transport, this); _protocolListener.ProtocolSession = _protocolSession; // Now start the connection "handshake". _transport.ProtocolWriter.Write(new ProtocolInitiation()); // Blocks until the connection has been opened. _stateManager.AttainState(AMQState.CONNECTION_OPEN); _failoverPolicy.attainedConnection(); // XXX: Again this should be changed to a suitable notify. _connected = true; } catch (AMQException e) { _lastAMQException = e; throw; // rethrow } }
public void Connect() { _wrappedTransport.Connect(); }
public void ConnectUser(string address, string port) { _transport.Connect(address, port); }
public void Connect(string url) { _transport.Connect(url); }
/// <summary> Connects to a transport layer defined through the current settings. </summary> /// <returns> true if it succeeds, false if it fails. </returns> public bool Connect() { return(_transport.Connect()); }
/// <summary> Connects to a transport layer defined through the current settings. </summary> /// <returns> true if it succeeds, false if it fails. </returns> public bool Connect() { return(!_transport.IsConnected() && _transport.Connect()); }
public void Connect(SslProtocols sslProtocols = SslProtocols.None) { transport.Connect(sslProtocols); }
public void Connect() => _transport.Connect();
/// <summary> /// Connects to the server on the specified address. /// </summary> /// <param name = "address">The address.</param> public void Connect() { _transport.OnOpen += () => _transport.Send(_serializer.Serialize(new StompMessage("CONNECT"))); _transport.OnMessage += (msg) => HandleMessage(_serializer.Deserialize(msg)); _transport.Connect(); }
internal void Add(ITransport transport, TransportCallback connectCallback) { try { // XXX: This should be negotiated as part of the initial handshake. transport.Encryptor = new AESTransportEncryptor(); transports.Add (transport); if (NewTransportAdded != null) NewTransportAdded (transport); LoggingService.LogInfo(String.Format ("Transport {0} added", transport.ToString())); if (transport.Incoming == true) { if (connectCallback != null) throw new ArgumentException ("You can only specify a ConnectCallback for outoging connections!"); if (transport.Encryptor != null) { DiffieHellmanManaged dh = new DiffieHellmanManaged (); byte[] keyxBytes = new byte[transport.Encryptor.KeyExchangeLength]; transport.Receive (keyxBytes, 0, keyxBytes.Length); keyxBytes = dh.DecryptKeyExchange (keyxBytes); byte[] keyBytes = new byte[transport.Encryptor.KeySize]; byte[] ivBytes = new byte[transport.Encryptor.IvSize]; Array.Copy (keyxBytes, 0, keyBytes, 0, keyBytes.Length); Array.Copy (keyxBytes, keyBytes.Length, ivBytes, 0, ivBytes.Length); keyxBytes = dh.CreateKeyExchange (); transport.Send (keyxBytes, 0, keyxBytes.Length); transport.Encryptor.SetKey(keyBytes, ivBytes); } //Receive connection type, which is a ulong (8 bytes) byte[] responseBuffer = new byte[8]; transport.Receive (responseBuffer, 0, 8); ulong connectionType = EndianBitConverter.ToUInt64 (responseBuffer, 0); // Recieve network ID (64 bytes) responseBuffer = new byte[64]; transport.Receive (responseBuffer, 0, 64); string networkId = EndianBitConverter.ToString (responseBuffer).Replace ("-", ""); // Match to one of our known networks! foreach (Network network in Core.Networks) { if (network.NetworkID == networkId) { transport.Network = network; } } if (transport.Network == null) { throw new Exception (String.Format ("Unknown network: {0}.", networkId)); } transport.ConnectionType = connectionType; if (connectionType == ConnectionType.NodeConnection) { LocalNodeConnection connection = new LocalNodeConnection(transport); transport.Operation = connection; transport.Network.AddConnection(connection); connection.Start(); } else if (connectionType == ConnectionType.TransferConnection) { Core.FileTransferManager.NewIncomingConnection(transport); } else { throw new Exception(String.Format("Unknown connection type: {0}.", connectionType.ToString())); } } else { if (connectCallback == null) { throw new ArgumentNullException("connectCallback"); } connectCallbacks.Add (transport, connectCallback); LoggingService.LogInfo("Transport {0} connecting...", transport); TransportCallback callback = new TransportCallback (OnConnected); transport.Connect (callback); } } catch (Exception ex) { transport.Disconnect (ex); RaiseTransportError(transport, ex); } }
public void Connect(string hostname, int port) { clientmode = true; transport.Connect(new IPEndPoint(Dns.GetHostAddresses(hostname)[0], port)); Send("ST_Connect", new byte[1], 0, ControlChannel); }