public void Save_Stores_ProtocolLines_In_The_File()
{
string projectName = "projectName";
string protocolName = "protocolName";
OpcMockProtocol omp = new OpcMockProtocol(protocolName);
string ompLine1 = "Set;tagPath1;tagValue1;192";
string ompLine2 = "Set;tagPath2;tagValue2;192";
omp.Append(new ProtocolLine(ompLine1));
omp.Append(new ProtocolLine(ompLine2));
string protocolFilePath = TestContext.TestDeploymentDir + Path.DirectorySeparatorChar + protocolName + FileExtensionContants.FileExtensionProtocol;
ProtocolWriter protocolWriter = new ProtocolWriter(TestContext.TestDeploymentDir, projectName);
protocolWriter.Save(omp);
string expectedFileContent = ompLine1 + Environment.NewLine + ompLine2 + Environment.NewLine;
string actualFileContent = File.ReadAllText(protocolFilePath);
Assert.AreEqual(expectedFileContent, actualFileContent);
File.Delete(protocolFilePath);
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.ObjectType);
return(writer.GetBuffer());
}
public CobbleConnection(ConnectionContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_reader = context.CreateReader();
_writer = context.CreateWriter();
_protocol = new HandshakingProtocol();
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Text);
return writer.GetBuffer();
}
public MultiplexingSocketProtocol(ConnectionContext connection, IMessageReader <TInbound> messageReader, IMessageWriter <TOutbound> messageWriter, IMessageIdGenerator messageIdGenerator, IMessageIdParser messageIdParser)
{
this.connection = connection ?? throw new ArgumentNullException(nameof(connection));
this.reader = new ProtocolReader(this.connection.Transport.Input);
this.writer = new ProtocolWriter(this.connection.Transport.Output);
this.wrappedReader = new WrappedMessageReader <TInbound>(messageIdParser, messageReader);
this.wrappedWriter = new WrappedMessageWriter <TOutbound>(messageIdParser, messageWriter);
this.sourcePool = new ObjectPool <PooledValueTaskSource <MessageId> >(() => { return(new PooledValueTaskSource <MessageId>()); }, 100);
}
public async Task ConnectAsync(EndPoint endPoint)
{
// REVIEW: Should this be a static factory?
_connection = await _client.ConnectAsync(endPoint).ConfigureAwait(false);
_writer = _connection.CreateWriter();
_reader = _connection.CreateReader();
_readingTask = ProcessReadsAsync();
}
public void WriteRequestAndReadResponse()
{
//var properties = new Hashtable() { { "port", 8080 } };
//var channel = new TcpChannel(properties, null, new SoapServerFormatterSinkProvider());
//if using SOAP via TCP, messageRequestStream must be SOAP format
var channel = new TcpChannel(8080);
ChannelServices.RegisterChannel(channel, false);
var service = new ServiceClass();
ObjRef obj = RemotingServices.Marshal(service, "Remote");
var uri = "tcp://localhost:8080/Remote";
using (var client = new TcpClient())
{
client.Connect("localhost", 8080);
using (var stream = client.GetStream())
{
var messageRequest = new MethodCall(new Header[] {
new Header("__Uri", uri),
new Header("__MethodName", "Do"),
new Header("__MethodSignature", new Type[] { typeof(string) }),
new Header("__TypeName", typeof(ServiceClass).AssemblyQualifiedName),
new Header("__Args", new object[] { "Hi" })
});
var messageRequestStream = BinaryFormatterHelper.SerializeObject(messageRequest);
var writer = new ProtocolWriter(stream);
writer.WritePreamble();
writer.WriteMajorVersion();
writer.WriteMinorVersion();
writer.WriteOperation(TcpOperations.Request);
writer.WriteContentDelimiter(TcpContentDelimiter.ContentLength);
writer.WriteContentLength(messageRequestStream.Length);
writer.WriteTransportHeaders(uri);
writer.WriteBytes(messageRequestStream);
var reader = new ProtocolReader(stream);
Console.WriteLine("Preamble: {0}", reader.ReadPreamble());
Console.WriteLine("MajorVersion: {0}", reader.ReadMajorVersion());
Console.WriteLine("MinorVersion: {0}", reader.ReadMinorVersion());
var op = reader.ReadOperation();
Assert.AreEqual(TcpOperations.Reply, op);
Console.WriteLine("Operation: {0}", op);
Console.WriteLine("ContentDelimiter: {0}", reader.ReadContentDelimiter());
var length = reader.ReadContentLength();
Console.WriteLine("ContentLength: {0}", length);
reader.ReadTransportHeaders();
var messageResponse = BinaryFormatterHelper.DeserializeObject(reader.ReadBytes(length)) as MethodResponse;
Assert.IsNotNull(messageResponse);
DumpHelper.DumpMessage(messageResponse);
if (messageResponse.Exception != null)
throw messageResponse.Exception;
Assert.AreEqual("Hi", messageResponse.ReturnValue);
}
}
}
public void ProtocolWriter_Is_Created_With_A_Folder_Path()
{
string folderPath = "folderPath";
string projectName = "projectName";
ProtocolWriter protocolWriter = new ProtocolWriter(folderPath, projectName);
Assert.AreEqual(folderPath, protocolWriter.FolderPath);
Assert.AreEqual(projectName, protocolWriter.ProjectName);
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.TickId);
writer.Write(this.Time);
writer.Write(this.NewPosition);
return(writer.GetBuffer());
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.TickId);
writer.Write(this.Time);
writer.Write(this.NewPosition);
return writer.GetBuffer();
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.Position);
writer.Write(this.SlotObject1);
writer.Write(this.SlotObject2);
return writer.GetBuffer();
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.ObjectId);
writer.Write(this.SlotId);
writer.Write(this.ItemUsePosition);
return writer.GetBuffer();
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.Position);
writer.Write(this.SlotObject1);
writer.Write(this.SlotObject2);
return(writer.GetBuffer());
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.ObjectId);
writer.Write(this.SlotId);
writer.Write(this.ItemUsePosition);
return(writer.GetBuffer());
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.BulletId);
writer.Write(this.ContainerType);
writer.Write(this.StartingPosition);
writer.Write(this.Angle);
return(writer.GetBuffer());
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.Time);
writer.Write(this.BulletId);
writer.Write(this.ContainerType);
writer.Write(this.StartingPosition);
writer.Write(this.Angle);
return writer.GetBuffer();
}
public MemcachedProtocol(ConnectionContext connection)
{
_connection = connection;
_protocolReader = connection.CreateReader();
_protocolWriter = connection.CreateWriter();
_semaphore = new SemaphoreSlim(1);
_memcachedMessageWriter = new MemcachedMessageWriter();
_memcachedMessageReader = new MemcachedMessageReader();
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.BuildVersion);
writer.Write(this.GameID);
writer.Write(this.GUID);
writer.Write(this.Password);
writer.Write(this.Secret);
return(writer.GetBuffer());
}
public void WriteTo(ProtocolWriter writer)
{
switch (ApiVersion)
{
case 0:
// Nothing to write
break;
default:
throw new UnknownApiVersionException(ApiVersion, ApiKey);
}
}
public override byte[] Write()
{
ProtocolWriter writer = new ProtocolWriter();
writer.Write(this.BuildVersion);
writer.Write(this.GameID);
writer.Write(this.GUID);
writer.Write(this.Password);
writer.Write(this.Secret);
return writer.GetBuffer();
}
private void CloseConnection()
{
_stateManager.ChangeState(AMQState.CONNECTION_CLOSING);
AMQFrame frame = ConnectionCloseBody.CreateAMQFrame(
0, 200, "Qpid.NET client is closing the connection.", 0, 0);
ProtocolWriter.Write(frame);
_log.Debug("Blocking for connection close ok frame");
Disconnect();
}
/// <summary>COM_STATISTICS, Get a human readable string of internal statistics.</summary>
public string Statistics()
{
using (var stream = client.GetStream())
{
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
ProtocolWriter.WriteStatistics(ref writer);
var reader = SyncWriteAndRead(ref writer, 0, stream);
reader.ThrowIfErrorPacket();
var result = reader.ReadString(reader.Remaining);
return(result);
}
}
public TextResultSet Query(string query)
{
var stream = client.GetStream();
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
ProtocolWriter.WriteQuery(ref writer, query);
var reader = SyncWriteAndRead(ref writer, 0, stream);
// TODO: Ok or ResultSet?
var set = ProtocolReader.ReadTextResultSet(ref reader);
return(set);
}
/// <summary>COM_PING, check if the server is alive.</summary>
public OkPacket Ping()
{
using (var stream = client.GetStream())
{
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
ProtocolWriter.WritePing(ref writer);
var reader = SyncWriteAndRead(ref writer, 0, stream);
var response = ProtocolReader.ReadResponsePacket(ref reader);
response.ThrowIfError();
return((OkPacket)response);
}
}
public void Save_Creates_A_Protocol_File_In_The_FolderPath()
{
string projectName = "projectName";
string protocolName = "protocolName";
OpcMockProtocol opcMockProtocol = new OpcMockProtocol(protocolName);
ProtocolWriter protocolWriter = new ProtocolWriter(TestContext.TestDeploymentDir, projectName);
protocolWriter.Save(opcMockProtocol);
string protocolFilePath = TestContext.TestDeploymentDir + Path.DirectorySeparatorChar + protocolName + FileExtensionContants.FileExtensionProtocol;
Assert.IsTrue(File.Exists(protocolFilePath));
File.Delete(protocolFilePath);
}
public StatementPrepareOk Prepare(string query)
{
var stream = client.GetStream();
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
ProtocolWriter.WritePrepareStatement(ref writer, query);
var reader = SyncWriteAndRead(ref writer, 0, stream);
// COM_STMT_PREPARE_OK on success, ERR_Packet otherwise
if (reader.IsErrorPacket())
{
throw ErrorPacket.Parse(ref reader).ToMySqlException();
}
return(ProtocolReader.ReadStatementPrepareOk(ref reader));
}
/// <summary>
/// on connected as an asynchronous operation.
/// </summary>
/// <param name="connection">The new <see cref="T:Microsoft.AspNetCore.Connections.ConnectionContext" /></param>
/// <returns>A <see cref="T:System.Threading.Tasks.Task" /> that represents the connection lifetime. When the task completes, the connection is complete.</returns>
public override async Task OnConnectedAsync(ConnectionContext connection)
{
this.context = connection;
this.reader = connection.CreateReader();
this.writer = connection.CreateWriter();
SessionManager.Singleton.AcceptSession(connection, writer, this.protocol);
//IConnectionHeartbeatFeature heartbeatFeature = connection.Features.Get<IConnectionHeartbeatFeature>();
//heartbeatFeature.OnHeartbeat(this.SendHeartbeat, null);
while (true)
{
try
{
var result = await reader.ReadAsync(protocol);
var message = result.Message;
_logger.LogInformation("Received a message of {Length} bytes", message.Payload.Length);
if (result.IsCompleted)
{
break;
}
await writer.WriteAsync(protocol, message);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
connection.Abort();
break;
}
finally
{
reader.Advance();
}
}
}
private void MakeBrokerConnection(IBrokerInfo brokerDetail)
{
try
{
_stateManager = new AMQStateManager();
_protocolListener = new AMQProtocolListener(this, _stateManager);
_protocolListener.AddFrameListener(_stateManager);
/*
* // Currently there is only one transport option - BlockingSocket.
* String assemblyName = "Apache.Qpid.Client.Transport.Socket.Blocking.dll";
* String transportType = "Apache.Qpid.Client.Transport.Socket.Blocking.BlockingSocketTransport";
*
* // Load the transport assembly dynamically.
* _transport = LoadTransportFromAssembly(brokerDetail.getHost(), brokerDetail.getPort(), assemblyName, transportType);
*/
_transport = new BlockingSocketTransport();
// Connect.
_transport.Connect(brokerDetail, this);
_protocolWriter = new ProtocolWriter(_transport.ProtocolWriter, _protocolListener);
_protocolSession = new AMQProtocolSession(_transport.ProtocolWriter, _transport, this);
_protocolListener.ProtocolSession = _protocolSession;
// Now start the connection "handshake".
_transport.ProtocolWriter.Write(new ProtocolInitiation());
// Blocks until the connection has been opened.
_stateManager.AttainState(AMQState.CONNECTION_OPEN);
_failoverPolicy.attainedConnection();
// XXX: Again this should be changed to a suitable notify.
_connected = true;
}
catch (AMQException e)
{
_lastAMQException = e;
throw; // rethrow
}
}
public async Task ShortLengthMaskedWorksViaManagedWebSocket()
{
var options = new PipeOptions(useSynchronizationContext: false);
var duplexPipe = DuplexPipe.CreateConnectionPair(options, options);
var webSocket = WebSocket.CreateFromStream(new DuplexPipeStream(duplexPipe.Application.Input, duplexPipe.Application.Output), true, null, TimeSpan.FromSeconds(30));
var writer = new WebSocketFrameWriter();
var payloadString = String.Join(String.Empty, Enumerable.Repeat("This is a test payload.", 25));
var payloadBuffer = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(payloadString));
var header = WebSocketHeader.CreateMasked(true, WebSocketOpcode.Binary, (ulong)payloadBuffer.Length);
var protocolWriter = new ProtocolWriter(duplexPipe.Transport.Output);
await protocolWriter.WriteAsync(writer, new WebSocketWriteFrame(header, payloadBuffer));
var receiveBuffer = new Memory <byte>(new byte[payloadBuffer.Length]);
await webSocket.ReceiveAsync(receiveBuffer, default);
Assert.Equal(payloadString, Encoding.UTF8.GetString(receiveBuffer.ToArray()));
}
/// <summary>
/// try send as an asynchronous operation.
/// </summary>
/// <param name="requestMessage">The request message.</param>
/// <param name="cancellationToken">
/// The cancellation token that can be used by other objects or threads to receive notice
/// of cancellation.
/// </param>
/// <returns>A Task<FlushResult> representing the asynchronous operation.</returns>
/// <exception cref="TheDesolatedTunnels.RelayServer.Core.Exceptions.ConnectionNotFoundException"></exception>
/// <autogeneratedoc />
public async ValueTask TrySendAsync(SixtyNineSendibleMessage requestMessage,
CancellationToken cancellationToken = default)
{
await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
var connection = _connectionStore[requestMessage.Destination] ??
throw new ConnectionNotFoundException(requestMessage.Destination);
// Write request message length
//_messageWriter.WriteMessage(requestMessage, connection.Transport.Output);
var ff = new ProtocolWriter(connection.Transport.Output);
await ff.WriteAsync(_messageWriter, requestMessage, cancellationToken);
}
finally
{
_semaphore.Release();
}
//return await connection.Transport.Output.FlushAsync(cancellationToken);
}
// Protected implementation of Dispose pattern.
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
// Free any other managed objects here.
//
this._logger = null;
this.protocol = null;
this.writer = null;
this.reader = null;
}
// Free any unmanaged objects here.
//
disposed = true;
}
public BinaryResultSet Execute(int statementId, params object[] parameters) // how to avoid boxing?
{
var stream = client.GetStream();
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
ProtocolWriter.WriteExecuteStatement(ref writer, statementId, parameters);
var reader = SyncWriteAndRead(ref writer, 0, stream);
// COM_STMT_PREPARE_OK on success, ERR_Packet otherwise
if (reader.IsErrorPacket())
{
throw ErrorPacket.Parse(ref reader).ToMySqlException();
}
// TODO: Ok or ResultSet?
var set = ProtocolReader.ReadBinaryResultSet(ref reader);
return(set);
}
public override async Task OnConnectedAsync(ConnectionContext connection)
{
this.EnsurePeerCanConnect(connection);
// Use a length prefixed protocol
var protocol = new NetworkMessageProtocol(this.loggerFactory.CreateLogger <NetworkMessageProtocol>(), this.chainDefinition);
ProtocolReader <Message> reader = Protocol.CreateReader(connection, protocol);
ProtocolWriter <Message> writer = Protocol.CreateWriter(connection, protocol);
while (true)
{
Message message = await reader.ReadAsync();
this.logger.LogInformation("Received a message of {Length} bytes", message.Payload.Length);
await this.ParseMessage(message, connection).ConfigureAwait(false);
// REVIEW: We need a ReadResult<T> to indicate completion and cancellation
if (message.Payload == null)
{
break;
}
}
}
public TextResultSet Query(FormattableString query)
{
if (query.ArgumentCount == 0)
{
return(Query(query.Format));
}
var stream = client.GetStream();
var readWriteBuffer = InternalMemoryPool.GetBuffer();
var writer = PacketWriter.Create(readWriteBuffer);
var charBuffer = InternalMemoryPool.GetCharBuffer();
var stringCount = FastQueryParser.Parse(ref charBuffer, query);
ProtocolWriter.WriteQuery(ref writer, charBuffer, stringCount);
var reader = SyncWriteAndRead(ref writer, 0, stream);
// TODO: Ok or ResultSet?
var set = ProtocolReader.ReadTextResultSet(ref reader);
return(set);
}
public override async Task OnConnectedAsync(ConnectionContext connection)
{
Logger.Debug($"Connecting to {_proxySettings.RemoteHost}:{_proxySettings.RemotePort}");
var proxyClient = new TcpClient();
await proxyClient.ConnectAsync(_proxySettings.RemoteHost, _proxySettings.RemotePort);
var ogStream = proxyClient.GetStream();
Stream proxyStream = ogStream;
if (_proxySettings.Secure)
{
var protocol = new TlsClientProtocol(proxyStream, new Org.BouncyCastle.Security.SecureRandom());
protocol.Connect(new BlazeTlsClient());
proxyStream = protocol.Stream;
}
var blazeProtocol = new BlazeProxyProtocol();
var localReader = connection.CreateReader();
var localWriter = connection.CreateWriter();
var remoteReader = new ProtocolReader(proxyStream);
var remoteWriter = new ProtocolWriter(proxyStream);
while (true)
{
try
{
var result = await localReader.ReadAsync(blazeProtocol);
var message = result.Message;
if (message != null)
{
var header = message.Header;
Logger.Debug(
$"Client -> Proxy; Length:{header.Length} Component:{header.Component} Command:0x{header.Command:X2} ErrorCode:{header.ErrorCode} MessageType:{header.MessageType} MessageId:{header.MessageId}");
var requestPayload = message.Payload;
if (!requestPayload.IsEmpty)
{
if (!_parser.TryParseBody(requestPayload))
{
Logger.Error("Failed to parse request message");
}
}
await remoteWriter.WriteAsync(blazeProtocol, message);
}
if (result.IsCompleted)
{
break;
}
}
finally
{
localReader.Advance();
}
do
{
try
{
var result = await remoteReader.ReadAsync(blazeProtocol);
var message = result.Message;
if (message != null)
{
var header = message.Header;
Logger.Debug(
$"Proxy <- Server; Length:{header.Length} Component:{header.Component} Command:0x{header.Command:X2} ErrorCode:{header.ErrorCode} MessageType:{header.MessageType} MessageId:{header.MessageId}");
var responsePayload = message.Payload;
if (!responsePayload.IsEmpty)
{
if (!_parser.TryParseBody(responsePayload))
{
Logger.Error("Failed to parse response message");
}
}
await localWriter.WriteAsync(blazeProtocol, message);
}
if (result.IsCompleted)
{
break;
}
}
finally
{
remoteReader.Advance();
}
} while (ogStream.DataAvailable);
}
}
public RespBedrockProtocol(ConnectionContext connection, object state = null) : base(state)
{
// _connection = connection;
_reader = connection.CreateReader();
_writer = connection.CreateWriter();
}
public RabbitMQClientProtocol(ConnectionContext connection)
{
_writer = connection.CreateWriter();
_reader = connection.CreateReader();
_formatter = new RabbitMQMessageFormatter();
}
