public void SendTelegram(string telegram, ConnectionChannel channel, bool logMessage) { string ChannelName = ""; if (ControllerConnection != null && DespatchConnection != null && plcConnected) { if (channel == ConnectionChannel.Main) { ChannelName = Name; ControllerConnection.Send(telegram); } else if (channel == ConnectionChannel.Despatch) { ChannelName = NameDespatch; DespatchConnection.Send(telegram); } if (logMessage) { LogTelegrams(string.Format("{0} ATC<{1}: {2}", DateTime.Now.ToString(), ChannelName, telegram), Color.Black); } } else { LogTelegrams(string.Format("Error: Cannot send message, controller {0} connection not configured; {1}", ChannelName, telegram), Color.Red); } }
private async Task DisconnectCore(bool sendClose, bool disconnectSocket, CancellationToken token) { if (connected) { Connected = false; using (var sync = await clientConnectLock.LockAsync(token).ConfigureAwait(false)) { if (sendClose) { await ConnectionChannel.CloseConnection(token).ConfigureAwait(false); } if (disconnectSocket) { await ChromecastSocketService.Disconnect(token).ConfigureAwait(false); } var abortTasks = new List <Task>(); foreach (var channel in Channels) { abortTasks.Add(channel.Abort().WaitForFinishNoException()); } await Task.WhenAll(abortTasks.ToArray()).ConfigureAwait(false); } } }
private async Task DisconnectCore(bool sendClose, CancellationToken token) { await clientConnectLock.WaitAsync(token).ConfigureAwait(false); try { List <Task> abortTasks = new List <Task>(); foreach (var channel in Channels) { abortTasks.Add(channel.Abort()); } await Task.WhenAll(abortTasks.ToArray()).ConfigureAwait(false); if (sendClose) { await ConnectionChannel.CloseConnection(token).ConfigureAwait(false); } await ChromecastSocketService.Disconnect(token).ConfigureAwait(false); } finally { clientConnectLock.Release(); } }
public async Task Initialize(string host, string port, ConnectionChannel connectionChannel, HeartbeatChannel heartbeatChannel, Action <Stream, bool, CancellationToken> packetReader, CancellationToken cancellationToken) { if (_client == null) { _client = new TcpSocketClient(); } await _client.ConnectAsync(host, int.Parse(port), true, cancellationToken, true); await connectionChannel.OpenConnection(); heartbeatChannel.StartHeartbeat(); await Task.Run(async() => { while (true) { var sizeBuffer = new byte[4]; // First message should contain the size of message await _client.ReadStream.ReadAsync(sizeBuffer, 0, sizeBuffer.Length, cancellationToken); // The message is little-endian (that is, little end first), // reverse the byte array. Array.Reverse(sizeBuffer); //Retrieve the size of message var messageSize = BitConverter.ToInt32(sizeBuffer, 0); var messageBuffer = new byte[messageSize]; await _client.ReadStream.ReadAsync(messageBuffer, 0, messageBuffer.Length, cancellationToken); var answer = new MemoryStream(messageBuffer.Length); await answer.WriteAsync(messageBuffer, 0, messageBuffer.Length, cancellationToken); answer.Position = 0; packetReader(answer, true, cancellationToken); } }, cancellationToken); }
public string ReadLine() { string text = ConnectionChannel.ReadLine(); Session.AppendToLog(text); return(text); }
public async Task Connect(string host, int port, ConnectionChannel connectionChannel, HeartbeatChannel heartbeatChannel, Func <Stream, bool, CancellationToken, Task> packetReader, CancellationToken token) { await clientConnectLock.WaitAsync(token).ConfigureAwait(false); try { if (client != null) { throw new Exception("Already set"); } client = new ChromecastTcpClient(); stopTokenSource = new CancellationTokenSource(); combinedStopTokenSource = CancellationTokenSource.CreateLinkedTokenSource(stopTokenSource.Token, token); CancellationToken combinedToken = combinedStopTokenSource.Token; await client.ConnectAsync(host, port, combinedToken).ConfigureAwait(false); readTask = ProcessRead(packetReader, combinedToken); connectionChannel.OpenConnection(combinedStopTokenSource.Token); heartbeatChannel.StartHeartbeat(combinedStopTokenSource.Token); } finally { clientConnectLock.Release(); } }
public void WriteLine(string text, params object[] arg) { string formattedText = string.Format(text, arg); Session.AppendToLog(formattedText); ConnectionChannel.WriteLine(formattedText); }
private void connectCallback(IAsyncResult ar) { //The listener socket Socket listener = (Socket)ar.AsyncState; //The connected socket Socket socket = listener.EndAccept(ar); //Set the socket options socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1); //The channel instance ConnectionChannel channel = new ConnectionChannel(socket, pipelineFactory.getPipeline()); //Add the channel connectedChannels.Add(channel); //An empty packet instance Packet packet = new Packet(); //Begin receiving to the packet payload channel.getSocket().BeginReceive(packet.getPayload(), 0, packet.getPayload().Length, 0, new AsyncCallback(readCallback), new object[] { channel, packet }); // Start accepting another connection listener.BeginAccept(new AsyncCallback(connectCallback), listener); }
private void readCallback(IAsyncResult ar) { //The callback messages object[] messages = (object[])ar.AsyncState; //The channel ConnectionChannel channel = (ConnectionChannel)messages[0]; //The packet Packet packet = (Packet)messages[1]; try { //If we are unable to poll the channel's socket, it must be terminated if (channel.getSocket().Poll(1000, SelectMode.SelectRead)) { channel.getPipeline().getHandler().connectionTerminated(channel); connectedChannels.Remove(channel); return; } //Send the packet to the channel's decoder channel.getPipeline().getHandler().messageReceived(channel, channel.getPipeline().getDecoder().decode(channel, packet)); //Await another packet channel.getSocket().BeginReceive(packet.getPayload(), 0, packet.getPayload().Length, 0, new AsyncCallback(readCallback), new object[] { channel, packet }); } catch (Exception e) { //Send the exception to the channel's handler channel.getPipeline().getHandler().exceptionCaught(channel, e); } }
public async Task <string> ReadLineAsync() { string text = await ConnectionChannel.ReadLineAsync(); Session.AppendToLog(text); return(text); }
public async Task UnsubscribeFromChannel(string channel) { //IF A SUBSCRIPTION DELEGATE EXISTS if (_channelDelegates.ContainsKey(channel)) { //UNSUBSCRIBE FROM CHANNEL await _redis.Subscriber.UnsubscribeAsync(channel, _channelDelegates[channel]); //REMOVE SUBSCRIPTION DELEGATE _channelDelegates[channel] = null; _channelDelegates.Remove(channel); //REMOVE THE CHANNEL FROM THE DB IF IT EXISTS. RedisConnection conn = await GetConnection(); if (conn != null) { ConnectionChannel fCh = conn.Channels.SingleOrDefault(t => t.Name.Equals(channel, StringComparison.CurrentCultureIgnoreCase)); if (fCh != null) { conn.Channels.Remove(fCh); await SetConnection(conn); } } } }
public void Accept(Connection newConnection, ConnectionChannel channel) { connection = newConnection; Channel = channel; // call this directly to finish processing the first packet ReceiveCallback(); }
protected async Task WriteLineAndFlushAsync(string text, params object[] arg) { string formattedText = string.Format(text, arg); Session.AppendToLog(formattedText); await ConnectionChannel.WriteLineAsync(formattedText); await ConnectionChannel.FlushAsync(); }
// link channel to dispatcher private IConnectionChannel RegisterChannel(IChannel channel, IDispatcher <IConnectionSession> dispatcher, JsonMessageFactory factory, Func <IConnectionSession, bool> shouldOpen) { dispatchers.Add(dispatcher); var connectionChannel = new ConnectionChannel(channel, factory, dispatcher, shouldOpen, MessageLogger); connection.OnConnected(session => OnSessionConnected(session, connectionChannel)); connectionChannel.OnReceived((session, bytes) => OnReceive(connectionChannel, new ConnectionSession(session), bytes)); return(connectionChannel); }
public void SendToAll(object newData, PacketType packetType, bool important, ConnectionChannel channel) { var data = SerializeBinary(newData); var msg = Server.CreateMessage(); msg.Write((byte)packetType); msg.Write(data.Length); msg.Write(data); Server.SendToAll(msg, null, important ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.ReliableSequenced, (int)channel); }
public ChromeCastClient() { ChromecastSocketService = new ChromecastSocketService(); Channels = new List <IChromecastChannel>(); ConnectionChannel = new ConnectionChannel(this); Channels.Add(ConnectionChannel); HeartbeatChannel = new HeartbeatChannel(this); Channels.Add(HeartbeatChannel); ReceiverChannel = new ReceiverChannel(this); Channels.Add(ReceiverChannel); MediaChannel = new MediaChannel(this); Channels.Add(MediaChannel); }
public void Dispose() { if (!disposedValue) { HeartbeatChannel.Dispose(); ConnectionChannel.Dispose(); MediaChannel.Dispose(); ReceiverChannel.Dispose(); ChromecastSocketService?.Dispose(); } disposedValue = true; }
public async Task Connect(string host, int port, ConnectionChannel connectionChannel, HeartbeatChannel heartbeatChannel, Func <Stream, CancellationToken, Task> packetReader, CancellationToken token) { using (var sync = await clientConnectLock.LockAsync(token).ConfigureAwait(false)) { if (client != null) { throw new Exception("Already set"); } client = new ChromecastTcpClient(); combinedStopTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token); CancellationToken combinedToken = combinedStopTokenSource.Token; await client.ConnectAsync(host, port, combinedToken).ConfigureAwait(false); readTask = TaskHelper.StartAsync(() => ProcessRead(packetReader, combinedToken), combinedToken); connectionChannel.OpenConnection(combinedToken); heartbeatChannel.StartHeartbeat(combinedToken); } }
public void ApplyStreamFilter(Func <Stream, Stream> filter) { ConnectionChannel.ApplyStreamFilter(filter); }
private void OnSessionConnected(ISession session, ConnectionChannel channel) { var wrapper = new ConnectionSession(session); channel.ShouldOpen(wrapper); }
public static void SendToServer(object newData, PacketType packetType, bool important, ConnectionChannel channel) { var data = SerializeBinary(newData); NetOutgoingMessage msg = Client.CreateMessage(); msg.Write((byte)packetType); msg.Write(data.Length); msg.Write(data); Client.SendMessage(msg, important ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.ReliableSequenced, (int)channel); }
/// <summary> /// Called when a message is received from a channel's decoder /// </summary> /// /// <param name="channel"> /// The channel instance /// </param> /// /// <param name="message"> /// The message received /// </param> public virtual void messageReceived(ConnectionChannel channel, Object message) { }
public async Task ApplyStreamFilterAsync(Func <Stream, Task <Stream> > filter) { await ConnectionChannel.ApplyStreamFilterAsync(filter); }
public async Task CloseConnectionAsync() { await ConnectionChannel.CloseAync(); }
public void SetReaderEncoding(Encoding encoding) { ConnectionChannel.SetReaderEncoding(encoding); }
/// <summary> /// Called when a connection is terminated or declared disconnected /// </summary> /// /// <param name="channel"> /// The channel instance /// </param> public virtual void connectionTerminated(ConnectionChannel channel) { }
/// <summary> /// Called when an exception is thrown while handling a channel /// </summary> /// /// <param name="channel"> /// The channel /// </param> /// /// <param name="e"> /// The exception /// </param> public virtual void exceptionCaught(ConnectionChannel channel, Exception e) { }
/// <summary> /// Called when a new connection is made to the handler /// </summary> /// /// <param name="channel"> /// The channel instance /// </param> public virtual void newConnection(ConnectionChannel channel) { }
public async Task ProcessAsync() { try { Server.Behaviour.OnSessionStarted(this, Session); SetReaderEncoding(Server.Behaviour.GetDefaultEncoding(this)); if (Server.Behaviour.IsSSLEnabled(this)) { await ConnectionChannel.ApplyStreamFilterAsync(async s => { SslStream sslStream = new SslStream(s); await sslStream.AuthenticateAsServerAsync(Server.Behaviour.GetSSLCertificate(this)); return(sslStream); }); Session.SecureConnection = true; } await WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.ServiceReady, Server.Behaviour.DomainName + " smtp4dev ready")); int numberOfInvalidCommands = 0; while (ConnectionChannel.IsConnected) { bool badCommand = false; SmtpCommand command = new SmtpCommand(await ReadLineAsync()); Server.Behaviour.OnCommandReceived(this, command); if (command.IsValid) { IVerb verbProcessor = VerbMap.GetVerbProcessor(command.Verb); if (verbProcessor != null) { try { await verbProcessor.ProcessAsync(this, command); } catch (SmtpServerException exception) { await WriteResponseAsync(exception.SmtpResponse); } } else { badCommand = true; } } else if (command.IsEmpty) { } else { badCommand = true; } if (badCommand) { numberOfInvalidCommands++; if (Server.Behaviour.MaximumNumberOfSequentialBadCommands > 0 && numberOfInvalidCommands >= Server.Behaviour.MaximumNumberOfSequentialBadCommands) { await WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.ClosingTransmissionChannel, "Too many bad commands. Bye!")); await CloseConnectionAsync(); } else { await WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorCommandUnrecognised, "Command unrecognised")); } } } } catch (IOException ioException) { Session.SessionError = ioException; Session.SessionErrorType = SessionErrorType.NetworkError; } catch (Exception exception) { Session.SessionError = exception; Session.SessionErrorType = SessionErrorType.UnexpectedException; } await CloseConnectionAsync(); Session.EndDate = DateTime.Now; Server.Behaviour.OnSessionCompleted(this, Session); }
public void FoundService(ConnectionChannel channel) { ConnectionChannels.Add(channel); }