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