| public SetBuffer ( System.ByteBuffer byteBuffer ) : void | ||
| byteBuffer | System.ByteBuffer | |
| Результат | void | |
public void ClientWebSocketTransportWriteWithoutConnectTest()
{
var websocket = new ClientWebSocket();
var clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null);
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
}
public void ClientWebSocketTransportReadTest()
{
var websocket = new ClientWebSocket();
var clientWebSocketTransport = new ClientWebSocketTransport(websocket, IotHubName, null, null);
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
byte[] byteArray = new byte[10];
args.SetBuffer(byteArray, 0, 10);
clientWebSocketTransport.ReadAsync(args);
}
void OnHandleTransportComplete(TransportAsyncCallbackArgs args)
{
args.SetBuffer(null, 0, 0);
args.CompletedCallback = null;
if (args.Exception != null)
{
args.Transport.SafeClose(args.Exception);
}
else
{
this.OnTransportAccepted(args);
}
}
void OnWriteHeaderComplete(TransportAsyncCallbackArgs args)
{
if (args.Exception != null)
{
this.Complete(args);
return;
}
AmqpTrace.Provider.AmqpLogOperationInformational(this, TraceOperation.Execute, "ReadHeader");
byte[] headerBuffer = new byte[AmqpConstants.ProtocolHeaderSize];
args.SetBuffer(headerBuffer, 0, headerBuffer.Length);
args.CompletedCallback = this.OnReadHeaderComplete;
this.reader.ReadBuffer(args);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.SetBuffer(buffer, offset, count);
args.CompletedCallback = onIOComplete;
args.UserToken = this;
args.UserToken2 = Tuple.Create(callback, state);
if (!this.transport.WriteAsync(args))
{
Fx.Assert(args.CompletedSynchronously, "args.CompletedSynchronously should be true if not pending");
this.CompleteOperation(args);
}
return(args);
}
public async Task ClientWebSocketTransportReadWithoutConnectTest()
{
var websocket = new ClientWebSocket();
var clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null);
var args = new TransportAsyncCallbackArgs();
var byteArray = new byte[10];
args.SetBuffer(byteArray, 0, 10);
if (clientWebSocketTransport.ReadAsync(args))
{
while (!readComplete)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
}
void WriteSecurityHeader(TransportAsyncCallbackArgs args)
{
// secure transport: header negotiation
TransportProvider provider = this.settings.TransportProviders[this.providerIndex];
this.sentHeader = new ProtocolHeader(provider.ProtocolId, provider.DefaultVersion);
#if DEBUG
this.sentHeader.Trace(true);
AmqpTrace.Provider.AmqpLogOperationVerbose(this, TraceOperation.Send, this.sentHeader);
#endif
ByteBuffer buffer = new ByteBuffer(new byte[AmqpConstants.ProtocolHeaderSize]);
this.sentHeader.Encode(buffer);
args.SetBuffer(buffer.Buffer, buffer.Offset, buffer.Length);
args.CompletedCallback = this.OnWriteHeaderComplete;
this.writer.WriteBuffer(args);
}
public void ReadWriteTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
websocket.ConnectAsync(uri, CancellationToken.None).Wait(CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, IotHubName, null, null);
// Test Write API
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onWriteOperationComplete;
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
// Test Read API
args.CompletedCallback = onReadOperationComplete;
clientWebSocketTransport.ReadAsync(args);
}
public async Task LegacyWebSocketWriteAfterAbortTest()
{
var websocket = new IotHubClientWebSocket(WebSocketConstants.SubProtocols.Amqpwsb10);
await websocket.ConnectAsync(IotHubName, Port, "ws://", TimeSpan.FromMinutes(1));
legacyClientWebSocketTransport = new LegacyClientWebSocketTransport(websocket, TimeSpan.FromMinutes(1), null, null);
legacyClientWebSocketTransport.Abort();
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
legacyClientWebSocketTransport.WriteAsync(args);
Assert.Fail("Did not throw object disposed exception");
}
public async Task LegacyWebSocketWriteAfterCloseTest()
{
var websocket = new IotHubClientWebSocket(WebSocketConstants.SubProtocols.Amqpwsb10);
await websocket.ConnectAsync(IotHubName, Port, "ws://", TimeSpan.FromMinutes(1));
legacyClientWebSocketTransport = new LegacyClientWebSocketTransport(websocket, TimeSpan.FromMinutes(1), null, null);
await legacyClientWebSocketTransport.CloseAsync(TimeSpan.FromSeconds(30));
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
legacyClientWebSocketTransport.WriteAsync(args);
}
public async Task LegacyWebSocketReadWriteTest()
{
var websocket = new IotHubClientWebSocket(WebSocketConstants.SubProtocols.Amqpwsb10);
await websocket.ConnectAsync(IotHubName, Port, "ws://", TimeSpan.FromMinutes(1));
legacyClientWebSocketTransport = new LegacyClientWebSocketTransport(websocket, TimeSpan.FromSeconds(60), null, null);
// Test Write API
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onWriteOperationComplete;
args.SetBuffer(byteArray, 0, byteArray.Length);
legacyClientWebSocketTransport.WriteAsync(args);
// Test Read API
args.CompletedCallback = onReadOperationComplete;
if (legacyClientWebSocketTransport.ReadAsync(args))
{
while (!readComplete)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
// Once Read operation is complete, close websocket transport
legacyClientWebSocketTransport.CloseAsync(TimeSpan.FromSeconds(30)).Wait(CancellationToken.None);
}
public async Task LegacyClientWebSocketTransportReadWithoutConnectTest()
{
var websocket = new IotHubClientWebSocket(WebSocketConstants.SubProtocols.Amqpwsb10);
var clientWebSocketTransport = new LegacyClientWebSocketTransport(websocket, TimeSpan.FromSeconds(60), null, null);
var args = new TransportAsyncCallbackArgs();
var byteArray = new byte[10];
args.SetBuffer(byteArray, 0, 10);
if (clientWebSocketTransport.ReadAsync(args))
{
while (!readComplete)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
await websocket.CloseAsync();
}
public void LegacyClientWebSocketTransportWriteWithoutConnectTest()
{
var websocket = new IotHubClientWebSocket(WebSocketConstants.SubProtocols.Amqpwsb10);
var clientWebSocketTransport = new LegacyClientWebSocketTransport(websocket, TimeSpan.FromSeconds(60), null, null);
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
}
void WriteSecurityHeader(TransportAsyncCallbackArgs args)
{
// secure transport: header negotiation
TransportProvider provider = this.settings.TransportProviders[this.providerIndex];
this.sentHeader = new ProtocolHeader(provider.ProtocolId, provider.DefaultVersion);
#if DEBUG
this.sentHeader.Trace(true);
AmqpTrace.Provider.AmqpLogOperationVerbose(this, TraceOperation.Send, this.sentHeader);
#endif
ByteBuffer buffer = new ByteBuffer(new byte[AmqpConstants.ProtocolHeaderSize]);
this.sentHeader.Encode(buffer);
args.SetBuffer(buffer.Buffer, buffer.Offset, buffer.Length);
args.CompletedCallback = this.OnWriteHeaderComplete;
this.writer.WriteBuffer(args);
}
public async Task ReadWriteTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
await websocket.ConnectAsync(uri, CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null);
// Test Write API
var args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onWriteOperationComplete;
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
// Test Read API
args.CompletedCallback = onReadOperationComplete;
if (clientWebSocketTransport.ReadAsync(args))
{
while (!readComplete)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
// Once Read operation is complete, close websocket transport
// Test Close API
await clientWebSocketTransport.CloseAsync(TimeSpan.FromSeconds(30));
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
#endif
{
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.SetBuffer(buffer, offset, count);
args.CompletedCallback = onIOComplete;
args.UserToken = this;
args.UserToken2 = Tuple.Create(callback, state);
if (!this.transport.ReadAsync(args))
{
Fx.Assert(args.CompletedSynchronously, "args.CompletedSynchronously should be true if not pending");
this.CompleteOperation(args);
}
return args;
}
public void ReadFrame()
{
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.UserToken = this;
args.SetBuffer(this.sizeBuffer, 0, this.sizeBuffer.Length);
args.CompletedCallback = onSizeComplete;
this.ReadCore(args);
}
bool HandleReadComplete(TransportAsyncCallbackArgs args)
{
bool completed = true;
Exception exception = null;
if (args.Exception != null)
{
exception = args.Exception;
}
else if (args.BytesTransfered == 0)
{
exception = new ObjectDisposedException(this.transport.ToString());
}
else if (args.BytesTransfered < args.Count)
{
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
completed = false;
}
if (completed)
{
if (exception != null || object.ReferenceEquals(args.CompletedCallback, onFrameComplete))
{
ByteBuffer buffer = null;
if (exception == null)
{
buffer = new ByteBuffer(args.Buffer, 0, args.Buffer.Length);
this.parent.OnReceiveBuffer(buffer);
}
else
{
this.parent.OnIoFault(exception);
}
}
else
{
// read size completed ok
uint size = AmqpBitConverter.ReadUInt(this.sizeBuffer, 0, this.sizeBuffer.Length);
if (size > this.maxFrameSize)
{
completed = true;
exception = new AmqpException(AmqpErrorCode.FramingError, CommonResources.GetString(CommonResources.InvalidFrameSize, size, this.maxFrameSize));
this.parent.OnIoFault(exception);
}
else
{
byte[] frameBuffer = new byte[size];
Buffer.BlockCopy(this.sizeBuffer, 0, frameBuffer, 0, this.sizeBuffer.Length);
args.SetBuffer(frameBuffer, this.sizeBuffer.Length, (int)size - this.sizeBuffer.Length);
args.CompletedCallback = onFrameComplete;
completed = false;
}
}
}
return completed;
}
public void WriteBuffer(TransportAsyncCallbackArgs args)
{
TransportAsyncCallbackArgs wrapperArgs = new TransportAsyncCallbackArgs();
wrapperArgs.SetBuffer(args.Buffer, args.Offset, args.Count);
wrapperArgs.CompletedCallback = AsyncBufferWriter.onWriteComplete;
wrapperArgs.UserToken = this;
wrapperArgs.UserToken2 = args;
this.Write(wrapperArgs);
}
public void ReadWriteAfterAbortTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
websocket.ConnectAsync(uri, CancellationToken.None).Wait(CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, IotHubName, null, null);
clientWebSocketTransport.Abort();
try
{
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
Assert.Fail("Did not throw object disposed exception");
}
catch(ObjectDisposedException)
{
}
try
{
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
byte[] byteArray = new byte[10];
args.SetBuffer(byteArray, 0, 10);
clientWebSocketTransport.ReadAsync(args);
Assert.Fail("Did not throw object disposed exception");
}
catch (ObjectDisposedException)
{
}
}
void OnWriteHeaderComplete(TransportAsyncCallbackArgs args)
{
if (args.Exception != null)
{
this.Complete(args);
return;
}
AmqpTrace.Provider.AmqpLogOperationInformational(this, TraceOperation.Execute, "ReadHeader");
byte[] headerBuffer = new byte[AmqpConstants.ProtocolHeaderSize];
args.SetBuffer(headerBuffer, 0, headerBuffer.Length);
args.CompletedCallback = this.OnReadHeaderComplete;
this.reader.ReadBuffer(args);
}
public void ReadBuffer(TransportAsyncCallbackArgs args)
{
TransportAsyncCallbackArgs wrapperArgs = new TransportAsyncCallbackArgs();
wrapperArgs.SetBuffer(args.Buffer, args.Offset, args.Count);
wrapperArgs.UserToken = this;
wrapperArgs.UserToken2 = args;
wrapperArgs.CompletedCallback = AsyncBufferReader.onReadComplete;
this.Read(wrapperArgs);
}
public async Task ReadAfterCloseTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
var uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
await websocket.ConnectAsync(uri, CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null);
await clientWebSocketTransport.CloseAsync(TimeSpan.FromSeconds(30));
var args = new TransportAsyncCallbackArgs();
var byteArray = new byte[10];
args.SetBuffer(byteArray, 0, 10);
args.CompletedCallback = onReadOperationComplete;
clientWebSocketTransport.ReadAsync(args);
}
bool HandleReadBufferComplete(TransportAsyncCallbackArgs args)
{
bool shouldContinue;
if (args.Exception != null)
{
this.asyncIo.ioHandler.OnIoFault(args.Exception);
shouldContinue = false;
}
else if (args.BytesTransfered == 0)
{
// connection closed by other side
this.asyncIo.ioHandler.OnIoFault(new AmqpException(AmqpErrorCode.ConnectionForced, null));
shouldContinue = false;
}
else
{
Fx.Assert(this.remainingBytes == args.Count, "remaining bytes should be the same as args.Count");
Fx.Assert(this.remainingBytes >= args.BytesTransfered, "remaining bytes cannot be less than args.BytesTransfered " + this.remainingBytes);
shouldContinue = true;
this.remainingBytes -= args.BytesTransfered;
if (this.remainingBytes > 0)
{
// Buffer partially completed.
Fx.Assert(args.BytesTransfered < args.Count, "bytes transfered should be less than count");
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
}
else
{
Fx.Assert(this.remainingBytes == 0, "remaining bytes should be 0");
switch (this.readState)
{
case ReadState.FrameBody:
this.HandleFrameBodyReadComplete(args);
break;
case ReadState.FrameSize:
this.HandleFrameSizeReadComplete(args);
break;
case ReadState.ProtocolHeader:
this.HandleProtocolHeaderReadComplete(args);
break;
default:
throw new AmqpException(AmqpErrorCode.IllegalState, null);
}
}
}
if (!shouldContinue)
{
this.Cleanup();
}
return shouldContinue;
}
public async Task WriteAfterAbortTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
await websocket.ConnectAsync(uri, CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null);
clientWebSocketTransport.Abort();
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
}
public void WriteFrame(Performative command, bool needReply)
{
try
{
#if DEBUG
Frame frame = new Frame(FrameType.Sasl) { Command = command };
frame.Trace(true);
AmqpTrace.Provider.AmqpLogOperationVerbose(this, TraceOperation.Send, frame);
#endif
ByteBuffer buffer = Frame.EncodeCommand(FrameType.Sasl, 0, command, 0);
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.SetBuffer(buffer);
args.CompletedCallback = onWriteFrameComplete;
args.UserToken = this;
args.UserToken2 = needReply;
this.writer.WriteBuffer(args);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.HandleException("WriteFrame", exception);
}
}
bool HandleWriteComplete(TransportAsyncCallbackArgs args)
{
bool done = true;
Exception exception = null;
if (args.Exception != null)
{
exception = args.Exception;
}
else if (args.BytesTransfered == 0)
{
exception = new ObjectDisposedException(this.transport.ToString());
}
else if (args.BytesTransfered < args.Count)
{
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
done = false;
}
TransportAsyncCallbackArgs innerArgs = (TransportAsyncCallbackArgs)args.UserToken2;
if (done && innerArgs.CompletedCallback != null)
{
innerArgs.Exception = exception;
innerArgs.BytesTransfered = innerArgs.Count;
innerArgs.CompletedCallback(innerArgs);
}
return done;
}
