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