public async Task SendMessageAsync(string message)
{
try
{
if (_messageWriter == null)
{
throw new Exception("SendMessageAsync: no writer");
}
_messageWriter.WriteString(message);
using (var cancellationTokenSource = new CancellationTokenSource(5000))
{
await _messageWriter.StoreAsync().AsTask(cancellationTokenSource.Token).ContinueWith((antecedent) =>
{
if (antecedent.Status != TaskStatus.RanToCompletion)
{
throw new Exception("SendMessageAsync cancelled due to timeout");
}
});
}
}
catch (Exception e)
{
Logger.Error("SendMessageAsync: " + e.Message);
ConnectionClosed = true;
_messageWriter?.Dispose();
}
}
public void Shutdown()
{
this.Log("Stopping push server");
_runningTokenSource?.Cancel();
_inboundReader?.Dispose();
_outboundWriter?.DetachStream();
_outboundWriter?.Dispose();
}
public void Shutdown()
{
this.Log("Stopping realtime server");
NetworkInformation.NetworkStatusChanged -= OnNetworkStatusChanged;
_runningTokenSource?.Cancel();
_inboundReader?.Dispose();
_outboundWriter?.DetachStream();
_outboundWriter?.Dispose();
}
private void Cleanup()
{
connectTimeoutCTS?.Cancel();
connectTimeoutCTS = null;
connectCTS?.Cancel();
connectCTS = null;
readCTS?.Cancel();
readCTS = null;
sendCTS?.Cancel();
sendCTS = null;
tlsUpgradeCTS?.Cancel();
tlsUpgradeCTS = null;
try
{
dataWriter?.DetachStream();
dataWriter?.Dispose();
dataWriter = null;
}
catch (Exception) { }
try
{
dataReader?.DetachStream();
dataReader?.Dispose();
dataReader = null;
}
catch (Exception) { }
socket?.Dispose();
socket = null;
}
public static void IndexUimfFile(string uimfFileLocation)
{
bool indexed = false;
using (var uimfReader = new DataReader(uimfFileLocation))
{
if (uimfReader.DoesContainBinCentricData())
{
indexed = true;
Console.WriteLine("Bin centric data found in dataset {0}.", uimfFileLocation);
}
else
{
Console.WriteLine("No bin centric data found for file {0}.", uimfFileLocation);
}
uimfReader.Dispose();
}
if (!indexed)
{
Console.WriteLine("Creating bin centric data for {0}.", uimfFileLocation);
using (DataWriter dataWriter = new DataWriter(uimfFileLocation))
{
dataWriter.CreateBinCentricTables();
dataWriter.Dispose();
}
}
}
public void disconnect()
{
if (state == ConnectionState.DISCONNECTED)
{
return;
}
setState(ConnectionState.DISCONNECTING);
Logger.Info("[TCPConnection2]: Disconnecting");
connectingCTS?.Cancel();
readingCTS?.Cancel();
tlsUpgradeCTS?.Cancel();
sendCTS?.Cancel();
try
{
dataReader?.DetachStream();
dataReader?.Dispose();
dataReader = null;
dataWriter?.DetachStream();
dataWriter?.Dispose();
dataWriter = null;
}
catch (Exception)
{
}
socket?.Dispose();
socket = null;
setState(ConnectionState.DISCONNECTED);
Logger.Info("[TCPConnection2]: Disconnected");
}
public void Dispose()
{
Listening = false;
_eventLoopCancellationTokenSource.Cancel(false);
DataWriter?.Dispose();
DataReader?.Dispose();
}
public void Shutdown()
{
Log("Stopping realtime server");
try
{
NetworkInformation.NetworkStatusChanged -= OnNetworkStatusChanged;
}
catch { }
try
{
_runningTokenSource?.Cancel();
}
catch { }
try
{
_inboundReader?.Dispose();
_outboundWriter?.DetachStream();
_outboundWriter?.Dispose();
}
catch { }
try
{
Socket?.Dispose();
}
catch { }
}
public void Dispose()
{
_writer?.Dispose();
_writer = null;
_tcpSocket?.Dispose();
_tcpSocket = null;
}
public async Task <bool> Send(byte[] data)
{
DataWriter writer = null;
try {
writer = new DataWriter(_port.OutputStream);
writer.WriteBytes(data);
Task <UInt32> storeAsyncTask;
lock (_mutex) {
if (_closeTokenSrc == null || _closeTokenSrc.IsCancellationRequested)
{
throw new OperationCanceledException();
}
storeAsyncTask = writer.StoreAsync().AsTask(_closeTokenSrc.Token);
}
uint bytesWritten = await storeAsyncTask;
return(bytesWritten == data.Length);
}
catch (OperationCanceledException) {
if (_disposing)
{
FreeResources();
}
return(false);
}
finally {
writer?.DetachStream();
writer?.Dispose();
}
}
private void DeInitialiseSerialDevice()
{
lock (_serialDeviceLock)
{
if (Enabled)
{
Enabled = false;
_readCancellationTokenSource?.Cancel();
_listenTask?.Wait();
_listenTask = null;
_readCancellationTokenSource?.Dispose();
_readCancellationTokenSource = null;
_dataReader?.DetachStream();
_dataReader?.Dispose();
_dataReader = null;
_dataWriter?.DetachStream();
_dataWriter?.Dispose();
_dataWriter = null;
_serialDevice?.Dispose();
_serialDevice = null;
}
}
}
public void Shutdown()
{
_runningTokenSource?.Cancel();
_inboundReader = null;
_outboundWriter?.DetachStream();
_outboundWriter?.Dispose();
_outboundWriter = null;
Log($"[{_instaApi.GetLoggedUser().UserName}] " + "Stopped pinging push server");
}
/// <summary>
/// Closes any open pipes.
/// </summary>
private void ShutdownIo()
{
// Close all pipes
InPipe?.Dispose();
OutPipe?.Dispose();
CtrlPipe?.Dispose();
}
/// <summary>
/// Dispose all the serial communication objects associated with this device. We may or may not try to
/// reconnect after this.
/// </summary>
public virtual void DisposeSerialObjeccts()
{
Log($"Disposing serial I/O objects of {DeviceLabel}");
_dataWriter?.Dispose();
_dataWriter = null;
_dataReader?.Dispose();
_dataReader = null;
_serialDevice?.Dispose();
_serialDevice = null;
}
public async Task Unbind()
{
Socket?.Dispose();
mDataWriter?.Dispose();
mDataReader?.Dispose();
Socket = null;
mDataWriter = null;
mDataReader = null;
}
public void Unbind()
{
Socket?.Dispose();
mDataWriter?.Dispose();
mDataReader?.Dispose();
Socket = null;
mDataWriter = null;
mDataReader = null;
}
private async Task <bool> OpenNetworkAsync()
{
if (_sensorConnection != null)
{
return(true);
}
// TODO winsock/Socket with IOCP vs. UWP sockets
try
{
_sensorConnection = new StreamSocket();
await _sensorConnection.ConnectAsync(_sensorAddress);
_dataReader = new DataReader(_sensorConnection.InputStream);
_dataWriter = new DataWriter(_sensorConnection.OutputStream);
_dataWriter.ByteOrder = ByteOrder.LittleEndian;
_dataReader.ByteOrder = ByteOrder.LittleEndian;
// write header/ protocol version/ connection config
var helloPacket = new HelloPacket(1);
helloPacket.Write(_dataWriter);
await _dataWriter.StoreAsync();
await _dataWriter.FlushAsync();
// read the response from the server
var asyncOperation = _dataReader.LoadAsync(8);
// TODO: timeout handling
if (!asyncOperation.AsTask().Wait(50000))
{
asyncOperation.Close();
asyncOperation.Cancel();
}
helloPacket = HelloPacket.Read(_dataReader);
// TODO: compare protocol versions
// Start receive loop
}
catch (Exception)
{
_sensorConnection?.Dispose();
_sensorConnection = null;
_dataReader?.Dispose();
_dataReader = null;
_dataWriter?.Dispose();
_dataWriter = null;
return(false);
}
return(true);
}
public async void SendMessageAsync(string message)
{
try
{
_messageWriter.WriteString(message);
await _messageWriter.StoreAsync();
}
catch (Exception e)
{
ConnectionClosed = true;
_messageWriter?.Dispose();
}
}
public void Dispose()
{
Cancel();
Task.Delay(TimeSpan.FromSeconds(CancelTimeoutSeconds));
_dataReader?.DetachBuffer();
_dataReader?.DetachStream();
_dataReader?.Dispose();
_dataWriter?.DetachBuffer();
_dataWriter?.DetachStream();
_dataWriter?.Dispose();
_snocModule?.Dispose();
_readCancellationTokenSource.Dispose();
}
public virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
_disposed = true;
_dataReader?.Dispose();
_dataWriter?.Dispose();
_streamSocket?.Dispose();
}
}
public async Task SendAsync(byte[] message)
{
try
{
if (_state == State.Running)
{
_serialPortStream.WriteBytes(message);
await _serialPortStream.StoreAsync();
}
}
catch
{
SetDeviceState(State.Broken);
try
{
_serialPortStream?.Dispose();
_device?.Dispose();
}
catch
{
}
}
}
public void DisconnectDevice(NanoDeviceBase device)
{
if (FindDevice(((device as NanoDevice <NanoSerialDevice>).Device.DeviceInformation as SerialDeviceInformation).DeviceInformation.Id) != null)
{
EventHandlerForSerialDevice.Current.CloseDevice();
inputStreamReader?.DetachStream();
inputStreamReader?.DetachBuffer();
inputStreamReader?.Dispose();
outputStreamWriter?.DetachStream();
outputStreamWriter?.DetachBuffer();
outputStreamWriter?.Dispose();
}
}
private async Task CharGenUdpAsync(DataWriter dw, string remotePort)
{
var start = rnd.Next(0, 95);
var str = MakePattern(start, 72);
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: reply with CharGen <<{str}>> to remote port {remotePort}");
dw.WriteString(str);
await dw.StoreAsync();
await dw.FlushAsync(); // NOTE: this flush doesn't actually do anything useful
Interlocked.Increment(ref Stats.NResponses);
dw.Dispose();
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP closing down the current writing socket for {str}");
}
private async void SendSocketData(int packetlength, short magic, short ver, int action, int param = 1, string body = "")
{
try
{
var playload = Encoding.UTF8.GetBytes(body);
if (packetlength == 0)
{
packetlength = playload.Length + 16;
}
var buffer = new byte[packetlength];
using (var ms = new MemoryStream(buffer))
{
//Array.Reverse(a)
var b = BitConverter.GetBytes(buffer.Length).ToArray().Reverse().ToArray();
ms.Write(b, 0, 4);
b = BitConverter.GetBytes(magic).ToArray().Reverse().ToArray();
ms.Write(b, 0, 2);
b = BitConverter.GetBytes(ver).ToArray().Reverse().ToArray();
ms.Write(b, 0, 2);
b = BitConverter.GetBytes(action).ToArray().Reverse().ToArray();
ms.Write(b, 0, 4);
b = BitConverter.GetBytes(param).ToArray().Reverse().ToArray();
ms.Write(b, 0, 4);
if (playload.Length > 0)
{
ms.Write(playload, 0, playload.Length);
}
DataWriter writer = new DataWriter(_clientSocket.OutputStream); //实例化writer对象，以StreamSocket的输出流作为writer的方向
// string content = "ABCDEFGH"; //发送一字符串
//byte[] data = Encoding.UTF8.GetBytes(content); //将字符串转换为字节类型，完全可以不用转换
writer.WriteBytes(buffer); //写入字节流，当然可以使用WriteString直接写入字符串
await writer.StoreAsync(); //异步发送数据
writer.DetachStream(); //分离
writer.Dispose(); //结束writer
// _netStream.WriteAsync(buffer, 0, buffer.Length);
// _netStream.FlushAsync();
}
}
catch (Exception)
{
}
}
static async void multicastSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs eventArguments)
{
try {
HostName remoteHostAddress = eventArguments.RemoteAddress;
uint len = eventArguments.GetDataReader().UnconsumedBufferLength;
string message = eventArguments.GetDataReader().ReadString(len).Trim();
int p = message.IndexOf(':');
if (p != -1)
{
string serverLogToken = message.Substring(0, p);
int port = Int32.Parse(message.Substring(p + 1));
if (serverLogToken == logToken && port > 0 && port < 65535)
{
Debug.WriteLine("[LOGGER] Found a Titanium log server: " + remoteHostAddress.DisplayName + ":" + port);
try {
tcpSocket = new StreamSocket();
tcpSocket.Control.KeepAlive = true;
await tcpSocket.ConnectAsync(remoteHostAddress, port.ToString());
tcpWriter = new DataWriter(tcpSocket.OutputStream);
// shutdown the multicast socket and start the tcp connection
multicastSocket.Dispose();
} catch {
if (tcpWriter != null)
{
tcpWriter.Dispose();
tcpWriter = null;
}
if (tcpSocket != null)
{
tcpSocket.Dispose();
tcpSocket = null;
}
}
}
}
} catch (Exception ex) {
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
Debug.WriteLine(ex.ToString());
}
}
/// <summary>
/// Выполняет закрытие потоков чтения, записи, соединения с сервером и очистку
/// </summary>
private void Clear()
{
StatusId = ConnectionStatus.ConnectionError;
if (_datareader != null)
{
_datareader.Dispose();
}
if (_datawriter != null)
{
_datawriter.Dispose();
}
if (_socket != null)
{
_socket.Dispose();
}
}
/// <summary>
/// This is the click handler for the 'CloseSockets' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private void CloseSockets_Click(object sender, RoutedEventArgs e)
{
object outValue;
if (CoreApplication.Properties.TryGetValue("clientDataWriter", out outValue))
{
// Remove the data writer from the list of application properties as we are about to close it.
CoreApplication.Properties.Remove("clientDataWriter");
DataWriter dataWriter = (DataWriter)outValue;
// To reuse the socket with other data writer, application has to detach the stream from the writer
// before disposing it. This is added for completeness, as this sample closes the socket in
// very next block.
dataWriter.DetachStream();
dataWriter.Dispose();
}
if (CoreApplication.Properties.TryGetValue("clientSocket", out outValue))
{
// Remove the socket from the list of application properties as we are about to close it.
CoreApplication.Properties.Remove("clientSocket");
DatagramSocket socket = (DatagramSocket)outValue;
socket.Dispose();
}
if (CoreApplication.Properties.TryGetValue("listener", out outValue))
{
// Remove the listener from the list of application properties as we are about to close it.
CoreApplication.Properties.Remove("listener");
DatagramSocket listener = (DatagramSocket)outValue;
listener.Dispose();
}
if (CoreApplication.Properties.ContainsKey("remotePeer"))
{
// Remove the remote perr from the list of application properties.
CoreApplication.Properties.Remove("remotePeer");
}
if (CoreApplication.Properties.ContainsKey("connected"))
{
CoreApplication.Properties.Remove("connected");
}
rootPage.NotifyUser("Socket and listener closed", NotifyType.StatusMessage);
}
static void CloseConnection()
{
hasConnected = false;
clientSocket.Dispose();
if (_Writer != null)
{
_Writer.DetachStream();
_Writer.Dispose();
}
if (_Reader != null)
{
_Reader.DetachStream();
_Reader.Dispose();
}
_Writer = null;
_Reader = null;
}
public void Close()
{
try
{
sr?.Dispose();
dw?.Dispose();
streamSocket?.Dispose();
sr = null;
dw = null;
streamSocket = null;
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine(exc.ToString());
System.Diagnostics.Debugger.Break();
}
}
private async void SendButton_Click(object sender, RoutedEventArgs e)
{
try
{
DataWriter writer = new DataWriter(connectedSocket.OutputStream);
writer.WriteBytes(Encoding.UTF8.GetBytes(SendMessageTextBox.Text));
SendMessageTextBox.Text = "";
await writer.StoreAsync();
writer.DetachStream();
writer.Dispose();
}
catch (Exception exception)
{
rootPage.NotifyUser(exception.Message, NotifyType.ErrorMessage);
}
}
private bool disposedValue = false; // To detect redundant calls
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
dataWriteObject.Dispose();
_ARE.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
