public async Task ConnectAsync()
{
_udpClient = new UdpClient();
string localIpAddress = Util.LocalHostNames().FirstOrDefault();
await _udpClient.ConnectAsync(new UriBuilder("udp", localIpAddress, 9761).Uri, new UriBuilder("udp", _ipAddress, 9760).Uri, CancellationToken.None);
}
/// <summary>
/// Attempts to connect to data input source.
/// </summary>
protected override void AttemptConnection()
{
// Starts historian packet parser
m_parser.Start();
// Starts listening for UDP data
m_client.ConnectAsync();
}
public async Task Listen(int port = DEFAULT_PORT)
{
await Task.Yield();
if (run)
{
try
{
#if (!PORTABLE)
udp = new UdpClient(port);
#else
udp = new Sockets.Plugin.UdpSocketClient();
await udp.ConnectAsync(IPAddress.Any.ToString(), port);
#endif
}
catch (Exception e)
{
OnErrored(e);
return;
}
}
#if (!PORTABLE)
while (run)
{
UdpReceiveResult result;
try
{
result = await udp.ReceiveAsync();
}
catch (ObjectDisposedException e) { OnErrored(e); }
catch (SocketException e)
{
OnErrored(e);
continue;
}
HandleRequest(result);
}
#else
if (run)
{
udp.MessageReceived += (s, e) =>
{
HandleRequest(e);
};
}
#endif
}
private static UdpClient ConnectUDPClient()
{
UdpClient udpClient = new UdpClient
{
ConnectionString = $"port={s_settings.UDPPort}; interface={s_settings.InterfaceIP}"
};
udpClient.ConnectionAttempt += UdpClient_ConnectionAttempt;
udpClient.ConnectionEstablished += UdpClient_ConnectionEstablished;
udpClient.ConnectionException += UdpClient_ConnectionException;
udpClient.ConnectionTerminated += UdpClient_ConnectionTerminated;
udpClient.ReceiveDataException += UdpClient_ReceiveDataException;
udpClient.ReceiveDataComplete += UdpClient_ReceiveDataComplete;
udpClient.ConnectAsync();
return(udpClient);
}
/// <summary>
/// Subscribes (or re-subscribes) to a data publisher for a set of data points.
/// </summary>
/// <param name="remotelySynchronized">Boolean value that determines if subscription should be remotely synchronized - note that data publisher may not allow remote synchronization.</param>
/// <param name="compactFormat">Boolean value that determines if the compact measurement format should be used. Set to <c>false</c> for full fidelity measurement serialization; otherwise set to <c>true</c> for bandwidth conservation.</param>
/// <param name="connectionString">Connection string that defines required and optional parameters for the subscription.</param>
/// <returns><c>true</c> if subscribe transmission was successful; otherwise <c>false</c>.</returns>
public virtual bool Subscribe(bool remotelySynchronized, bool compactFormat, string connectionString)
{
bool success = false;
if (!string.IsNullOrWhiteSpace(connectionString))
{
try
{
// Parse connection string to see if it contains a data channel definition
Dictionary<string, string> settings = connectionString.ParseKeyValuePairs();
UdpClient dataChannel = null;
string setting;
// Track specified time inclusion for later deserialization
if (settings.TryGetValue("includeTime", out setting))
m_includeTime = setting.ParseBoolean();
else
m_includeTime = true;
settings.TryGetValue("dataChannel", out setting);
if (!string.IsNullOrWhiteSpace(setting))
{
dataChannel = new UdpClient(setting);
dataChannel.ReceiveBufferSize = ushort.MaxValue;
dataChannel.MaxConnectionAttempts = -1;
dataChannel.ConnectAsync();
}
// Assign data channel client reference and attach to needed events
this.DataChannel = dataChannel;
// Setup subscription packet
MemoryStream buffer = new MemoryStream();
DataPacketFlags flags = DataPacketFlags.NoFlags;
byte[] bytes;
if (remotelySynchronized)
flags |= DataPacketFlags.Synchronized;
if (compactFormat)
flags |= DataPacketFlags.Compact;
// Write data packet flags into buffer
buffer.WriteByte((byte)flags);
// Get encoded bytes of connection string
bytes = m_encoding.GetBytes(connectionString);
// Write encoded connection string length into buffer
buffer.Write(EndianOrder.BigEndian.GetBytes(bytes.Length), 0, 4);
// Encode connection string into buffer
buffer.Write(bytes, 0, bytes.Length);
// Cache subscribed synchronization state
m_synchronizedSubscription = remotelySynchronized;
// Send subscribe server command with associated command buffer
success = SendServerCommand(ServerCommand.Subscribe, buffer.ToArray());
}
catch (Exception ex)
{
OnProcessException(new InvalidOperationException("Exception occurred while trying to make publisher subscription: " + ex.Message, ex));
}
}
else
OnProcessException(new InvalidOperationException("Cannot make publisher subscription without a connection string."));
return success;
}
