public void HeaderSerializer_Deserialize_BadLength_Throws() { var header = "A.00p168.68e999ca-a651-40f4-ad8f-3aaf781862b4.1\n"; var bytes = Encoding.ASCII.GetBytes(header); Assert.ThrowsException <InvalidDataException>(() => { var result = HeaderSerializer.Deserialize(bytes, 0, bytes.Length); }); }
public IEnumerator DataHandle() { while (true) { yield return(new WaitForSeconds(0.016f)); int readCount = receiveMsgs.Count; for (int i = 0; i < readCount; i++) { //패킷을 Dequeue 한다 //패킷 : 메시지 타입 + 메시지 내용 DataPacket packet; //lock (receiveLock) //{ packet = receiveMsgs.Dequeue(); //} HeaderData headerData = new HeaderData(); HeaderSerializer headerSerializer = new HeaderSerializer(); headerSerializer.SetDeserializedData(packet.msg); if (packet.endPoint == null) { headerSerializer.Deserialize(ref headerData); DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId, ref packet.msg); if (server_notifier.TryGetValue(headerData.id, out serverRecvNotifier)) { serverRecvNotifier(packet); } else { Debug.Log("DataHandler::Server.TryGetValue 에러 " + headerData.id); } } else { headerSerializer.UdpDeserialize(ref headerData); DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId + NetworkManager.udpId, ref packet.msg); if (p2p_notifier.TryGetValue(headerData.id, out p2pRecvNotifier)) { p2pRecvNotifier(packet, headerData.udpId); } else { Debug.Log("DataHandler::P2P.TryGetValue 에러 " + headerData.id); } } } } }
/// <inheritdoc /> public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken) { using (await _receiveBottleneck.Enter(cancellationToken)) { var connection = await GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.Connection.CreateCommand()) { selectCommand.CommandText = $@" DELETE from {_tableName} where id = ( select id from {_tableName} where recipient = @recipient and visible < clock_timestamp() and expiration > clock_timestamp() order by priority asc, id asc for update skip locked limit 1 ) returning id, headers, body "; selectCommand.Parameters.Add("recipient", NpgsqlDbType.Text).Value = _inputQueueName; try { using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken)) { if (!await reader.ReadAsync(cancellationToken)) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } catch (SqlException sqlException) when(sqlException.Number == OperationCancelledNumber) { // ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this: throw new TaskCanceledException("Receive operation was cancelled", sqlException); } } return(receivedTransportMessage); } }
/// <summary> /// Receives the next message by querying the messages table for a message with a recipient matching this transport's <see cref="Address"/> /// </summary> public async Task <TransportMessage> Receive(ITransactionContext context) { using (await _bottleneck.Enter()) { var connection = await GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.CreateCommand()) { selectCommand.CommandText = $@" SET NOCOUNT ON ;WITH TopCTE AS ( SELECT TOP 1 [id], [headers], [body] FROM [{_tableName}] M WITH (ROWLOCK, READPAST) WHERE M.[recipient] = @recipient AND M.[visible] < getdate() AND M.[expiration] > getdate() ORDER BY [priority] ASC, [id] ASC ) DELETE FROM TopCTE OUTPUT deleted.[id] as [id], deleted.[headers] as [headers], deleted.[body] as [body] " ; selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = _inputQueueName; using (var reader = await selectCommand.ExecuteReaderAsync()) { if (!await reader.ReadAsync()) { return(null); } var headers = reader["headers"]; var headersDictionary = _headerSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } return(receivedTransportMessage); } }
/// <summary> /// Maps a <seealso cref="MySqlDataReader"/> that's read a result from the message table into a <seealso cref="TransportMessage"/> /// </summary> /// <returns>A <seealso cref="TransportMessage"/> representing the row or <c>null</c> if no row was available</returns> protected static async Task <TransportMessage> ExtractTransportMessageFromReader(MySqlDataReader reader, CancellationToken cancellationToken) { if (await reader.ReadAsync(cancellationToken).ConfigureAwait(false) == false) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; return(new TransportMessage(headersDictionary, body)); }
public void HeaderSerializer_DeserializesFromAscii() { const string header = "A.000168.68e999ca-a651-40f4-ad8f-3aaf781862b4.1\n"; var bytes = Encoding.ASCII.GetBytes(header); var result = HeaderSerializer.Deserialize(bytes, 0, bytes.Length); Assert.Equal('A', result.Type); Assert.Equal(168, result.PayloadLength); Assert.Equal(Guid.Parse("68e999ca-a651-40f4-ad8f-3aaf781862b4"), result.Id); Assert.True(result.End); }
// private method // packet seperate id / data private bool SeperatePacket(byte[] originalData, out int packetID, out byte[] seperatedData) { PacketHeader header = new PacketHeader(); HeaderSerializer serializer = new HeaderSerializer(); serializer.SetDeserializedData(originalData); serializer.Deserialize(ref header); seperatedData = null; packetID = 0; return(true); }
private async Task ProcessMessageWithTransaction(ImapClient client, UniqueId messageId) { using (var transaction = new MailBasedTransaction(client, _endpointName)) { try { var pair = transaction.BeginTransaction(messageId); var messageNativeId = pair.Item1; var message = pair.Item2; var headers = HeaderSerializer.Deserialize(message.TextBody); if (headers.TryGetValue(Headers.TimeToBeReceived, out string ttbrString)) { var ttbr = TimeSpan.Parse(ttbrString); var sentTime = message.Date; if (sentTime + ttbr < DateTime.UtcNow) { return; } } var body = new byte[0]; if (message.Attachments.Any()) { var ms = new MemoryStream(); ((MimePart)message.Attachments.First()).Content.DecodeTo(ms); body = ms.ToArray(); } var transportTransaction = new TransportTransaction(); transportTransaction.Set(transaction); var shouldCommit = await HandleMessageWithRetries(messageNativeId, headers, body, transportTransaction); if (shouldCommit) { transaction.Commit(); _currentRetries.Remove(messageNativeId, out _); } } catch (Exception ex) { _log.Error(ex.Message, ex); transaction.Abort(); _criticalError.Raise(ex.Message, ex); } } }
//Tcp 데이터 수신 void TcpReceiveDataCallback(IAsyncResult asyncResult) { AsyncData asyncData = (AsyncData)asyncResult.AsyncState; Socket tcpSock = asyncData.sock; try { asyncData.msgSize = (short)tcpSock.EndReceive(asyncResult); } catch { Debug.Log("NetworkManager::HandleAsyncDataReceive.EndReceive 에러"); tcpSock.Close(); return; } if (asyncData.msgSize >= NetworkManager.packetId) { Array.Resize(ref asyncData.msg, asyncData.msgSize + NetworkManager.packetSource + NetworkManager.packetId); Debug.Log(asyncData.msg.Length); HeaderData headerData = new HeaderData(); HeaderSerializer headerSerializer = new HeaderSerializer(); headerSerializer.SetDeserializedData(asyncData.msg); headerSerializer.Deserialize(ref headerData); DataPacket packet = new DataPacket(headerData, asyncData.msg); lock (receiveLock) { try { //큐에 삽입 Debug.Log("Enqueue Message Length : " + packet.msg.Length); msgs.Enqueue(packet); } catch { Console.WriteLine("NetworkManager::HandleAsyncDataReceive.Enqueue 에러"); } } } //재 수신 asyncData = new AsyncData(tcpSock); tcpSock.BeginReceive(asyncData.msg, 0, NetworkManager.packetLength, SocketFlags.None, new AsyncCallback(TcpReceiveLengthCallback), asyncData); }
// 수신된 데이터가 어느 데이터 구조에 적합한지 판단후 등록된 함수 호출 public void ReceivePacket(byte[] data) { PacketHeader header = new PacketHeader(); HeaderSerializer serializer = new HeaderSerializer(); // 패킷 추출 serializer.Deserialize(data, ref header); int packetId = (int)header.packetId; int headerSize = sizeof(int); byte[] packetData = new byte[data.Length - headerSize]; Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length); // 등록된 적절한 receive함수 호출 notifier[packetId]((PacketId)packetId, packetData); }
/// <summary> /// Called whene the transport needs to process a newly received message. /// </summary> /// <param name="context"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken) { using (await _bottleneck.Enter(cancellationToken)) { var connection = await GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.CreateCommand()) { selectCommand.CommandText = $@" UPDATE {_tableName} SET process_id = @processId WHERE recipient = @recipient AND `visible` < now() AND `expiration` > now() AND process_id IS NULL ORDER BY `priority` ASC, `id` ASC LIMIT 1; SELECT `id`, `headers`, `body` FROM {_tableName} WHERE process_id = @processId ORDER BY ID LIMIT 1; DELETE FROM {_tableName} WHERE process_id = @processId;"; selectCommand.Parameters.Add(selectCommand.CreateParameter("recipient", DbType.String, _inputQueueName)); selectCommand.Parameters.Add(selectCommand.CreateParameter("processId", DbType.Guid, Guid.NewGuid())); try { using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken)) { if (!await reader.ReadAsync(cancellationToken)) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } catch (MySqlException sqlException) when(sqlException.Number == OperationCancelledNumber) { // ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this: throw new TaskCanceledException("Receive operation was cancelled", sqlException); } } return(receivedTransportMessage); } }
/// <inheritdoc /> public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken) { using (await _receiveBottleneck.Enter(cancellationToken)) { var connection = await GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.Connection.CreateCommand()) { selectCommand.CommandText = $"rebus_dequeue_{_tableName}"; selectCommand.CommandType = CommandType.StoredProcedure; selectCommand.Parameters.Add(new OracleParameter("recipientQueue", OracleDbType.VarChar, _inputQueueName, ParameterDirection.Input)); selectCommand.Parameters.Add(new OracleParameter("output", OracleDbType.Cursor, ParameterDirection.Output)); selectCommand.InitialLobFetchSize = -1; try { selectCommand.ExecuteNonQuery(); using (var reader = (selectCommand.Parameters["output"].Value as OracleCursor).GetDataReader()){ if (!await reader.ReadAsync(cancellationToken)) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } catch (OracleException exception) when(exception.Code == OperationCancelledNumber) { // ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this: throw new TaskCanceledException("Receive operation was cancelled", exception); } } return(receivedTransportMessage); } }
public void DataHandle() { while (true) { if (receiveMsgs.Count > 0) { DataPacket packet = new DataPacket(); //패킷을 Dequeue 한다 패킷 : 메시지 타입 + 메시지 내용, 소켓 lock (receiveLock) { try { packet = receiveMsgs.Dequeue(); } catch { Console.WriteLine("DataHandler::DataHandle.Dequeue 에러"); } } HeaderData headerData = new HeaderData(); HeaderSerializer headerSerializer = new HeaderSerializer(); headerSerializer.SetDeserializedData(packet.msg); headerSerializer.Deserialize(ref headerData); ResizeByteArray(0, UnityServer.packetSource + UnityServer.packetId, ref packet.msg); //Dictionary에 등록된 델리게이트 메소드에서 PacketId를 반환받는다. if (m_notifier.TryGetValue(headerData.id, out recvNotifier)) { recvNotifier(packet); } else { Console.WriteLine("DataHandler::DataHandle.TryGetValue 에러 "); Console.WriteLine("패킷 출처 : " + headerData.source); Console.WriteLine("패킷 ID : " + headerData.id); } } } }
public void Can_round_trip_headers() { var input = new Dictionary <string, string> { { "key 1", "value 1" }, { "key 2", "value 2" } }; var serialized = HeaderSerializer.Serialize(input); Approver.Verify(serialized); var deserialize = HeaderSerializer.Deserialize(serialized); CollectionAssert.AreEquivalent(input, deserialize); }
//Udp 데이터 수신 public void UdpReceiveDataCallback(IAsyncResult asyncResult) { AsyncData asyncData = (AsyncData)asyncResult.AsyncState; udpSock = asyncData.sock; try { Debug.Log("메시지 받음"); asyncData.msgSize = (short)udpSock.EndReceive(asyncResult); Debug.Log(asyncData.EP); } catch (Exception e) { Debug.Log("연결 끊김 :" + e.Message); udpSock.Close(); } if (asyncData.msgSize > 0) { byte[] msgSize = ResizeByteArray(0, NetworkManager.packetLength, ref asyncData.msg); Array.Resize(ref asyncData.msg, BitConverter.ToInt16(msgSize, 0) + NetworkManager.packetSource + NetworkManager.packetId); HeaderData headerData = new HeaderData(); HeaderSerializer headerSerializer = new HeaderSerializer(); headerSerializer.SetDeserializedData(asyncData.msg); headerSerializer.Deserialize(ref headerData); DataPacket packet = new DataPacket(headerData, asyncData.msg, asyncData.EP); lock (receiveLock) { //큐에 삽입 Debug.Log("Enqueue Message Length : " + asyncData.msg.Length); msgs.Enqueue(packet); } //다시 수신 준비 asyncData = new AsyncData(udpSock, asyncData.EP); udpSock.BeginReceiveFrom(asyncData.msg, 0, AsyncData.msgMaxSize, SocketFlags.None, ref asyncData.EP, new AsyncCallback(UdpReceiveDataCallback), asyncData); } }
public void ReceivePacket(byte[] data) { PacketHeader header = new PacketHeader(); HeaderSerializer serializer = new HeaderSerializer(); bool ret = serializer.Deserialize(data, ref header); if (ret == false) { // 패킷으로서 인식할 수 없으므로 폐기합니다. return; } if (m_udp != null && m_udp.IsCommunicating() == true) { // 통신상대로부터 첫 수신 시에 상호 통신할 수 있도록 접속 통지를 합니다. if (m_handler != null && m_eventOccured == false) { NetEventState state = new NetEventState(); state.type = NetEventType.Connect; state.result = NetEventResult.Success; state.endPoint = m_udp.GetRemoteEndPoint(); Debug.Log("Event handler call."); m_handler(state); m_eventOccured = true; } } int packetId = (int)header.packetId; if (m_notifier.ContainsKey(packetId) && m_notifier[packetId] != null) { int headerSize = Marshal.SizeOf(typeof(PacketHeader));//sizeof(PacketId) + sizeof(int); byte[] packetData = new byte[data.Length - headerSize]; Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length); m_notifier[packetId]((PacketId)packetId, packetData); } }
public void HeaderSerializer_CanRoundTrip() { var header = new Header() { Type = PayloadTypes.Request, PayloadLength = 168, Id = Guid.Parse("68e999ca-a651-40f4-ad8f-3aaf781862b4"), End = true, }; var buffer = new byte[1024]; const int offset = 0; var length = HeaderSerializer.Serialize(header, buffer, offset); var result = HeaderSerializer.Deserialize(buffer, 0, length); Assert.Equal(header.Type, result.Type); Assert.Equal(header.PayloadLength, result.PayloadLength); Assert.Equal(header.Id, result.Id); Assert.Equal(header.End, result.End); }
/// <inheritdoc /> public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken) { using (await _receiveBottleneck.Enter(cancellationToken)) { var connection = GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.Connection.CreateCommand()) { selectCommand.CommandText = $"{_table.Prefix}rebus_dequeue_{_table.Name}"; selectCommand.CommandType = CommandType.StoredProcedure; selectCommand.Parameters.Add(new OracleParameter("recipientQueue", OracleDbType.Varchar2, _inputQueueName, ParameterDirection.Input)); selectCommand.Parameters.Add(new OracleParameter("now", _rebusTime.Now.ToOracleTimeStamp())); selectCommand.Parameters.Add(new OracleParameter("output", OracleDbType.RefCursor, ParameterDirection.Output)); selectCommand.InitialLOBFetchSize = -1; selectCommand.ExecuteNonQuery(); using (var reader = (selectCommand.Parameters["output"].Value as OracleRefCursor).GetDataReader()) { if (!reader.Read()) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } return(receivedTransportMessage); } }
/// <summary> /// Receives the next message by querying the messages table for a message with a recipient matching this transport's <see cref="Address"/> /// </summary> public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken) { using (await _bottleneck.Enter(cancellationToken)) { var connection = await GetConnection(context); TransportMessage receivedTransportMessage; using (var selectCommand = connection.CreateCommand()) { selectCommand.CommandText = $@" SET NOCOUNT ON ;WITH TopCTE AS ( SELECT TOP 1 [id], [headers], [body] FROM [{_tableName}] M WITH (ROWLOCK, READPAST) WHERE M.[recipient] = @recipient AND M.[visible] < getdate() AND M.[expiration] > getdate() ORDER BY [priority] ASC, [id] ASC ) DELETE FROM TopCTE OUTPUT deleted.[id] as [id], deleted.[headers] as [headers], deleted.[body] as [body] " ; selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = _inputQueueName; try { using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken)) { if (!await reader.ReadAsync(cancellationToken)) { return(null); } var headers = reader["headers"]; var headersDictionary = HeaderSerializer.Deserialize((byte[])headers); var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } catch (SqlException sqlException) when(sqlException.Number == OperationCancelledNumber) { // ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this: throw new TaskCanceledException("Receive operation was cancelled", sqlException); } } return(receivedTransportMessage); } }
public Dictionary <string, string> Deserialize(byte[] bytes) { return(_utf8HeaderSerializer.Deserialize(bytes)); }
private async Task ReceivePacketsAsync() { bool isClosed = false; int length; DisconnectedEventArgs disconnectArgs = null; while (_receiver != null && _receiver.IsConnected && !isClosed) { // receive a single packet try { // read the header int headerOffset = 0; while (headerOffset < TransportConstants.MaxHeaderLength) { length = await _receiver.ReceiveAsync(_receiveHeaderBuffer, headerOffset, TransportConstants.MaxHeaderLength - headerOffset).ConfigureAwait(false); if (length == 0) { throw new TransportDisconnectedException("Stream closed while reading header bytes"); } headerOffset += length; } // deserialize the bytes into a header var header = HeaderSerializer.Deserialize(_receiveHeaderBuffer, 0, TransportConstants.MaxHeaderLength); // read the payload var contentStream = _getStream(header); var buffer = PayloadTypes.IsStream(header) ? new byte[header.PayloadLength] : _receiveContentBuffer; int offset = 0; if (header.PayloadLength > 0) { do { // read in chunks int count = Math.Min(header.PayloadLength - offset, TransportConstants.MaxPayloadLength); // read the content length = await _receiver.ReceiveAsync(buffer, offset, count).ConfigureAwait(false); if (length == 0) { throw new TransportDisconnectedException("Stream closed while reading payload bytes"); } if (contentStream != null) { // write chunks to the contentStream if it's not a stream type if (!PayloadTypes.IsStream(header)) { await contentStream.WriteAsync(buffer, offset, length).ConfigureAwait(false); } } offset += length; }while (offset < header.PayloadLength); // give the full payload buffer to the contentStream if it's a stream if (contentStream != null && PayloadTypes.IsStream(header)) { ((PayloadStream)contentStream).GiveBuffer(buffer, length); } } _receiveAction(header, contentStream, offset); } catch (TransportDisconnectedException de) { isClosed = true; disconnectArgs = new DisconnectedEventArgs() { Reason = de.Reason, }; } catch (Exception e) { isClosed = true; disconnectArgs = new DisconnectedEventArgs() { Reason = e.Message, }; } } Disconnect(disconnectArgs); }
/// <summary> /// Deserialize msmq-message from the extension property /// </summary> public Dictionary <string, string> Deserialize(Message msmqMessage) { return(_utf8HeaderSerializer.Deserialize(msmqMessage.Extension)); }
public async Task <TransportMessage> Receive(ITransactionContext context) { using (await _bottleneck.Enter()) { var connection = await GetConnection(context); long? idOfMessageToDelete; TransportMessage receivedTransportMessage; using (var selectCommand = connection.CreateCommand()) { selectCommand.CommandText = string.Format(@" SELECT TOP 1 [id], [headers], [body] FROM [{0}] WITH (UPDLOCK, READPAST, ROWLOCK) WHERE [recipient] = @recipient AND [expiration] > getdate() ORDER BY [priority] ASC, [id] asc ", _tableName); selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = _inputQueueName; using (var reader = await selectCommand.ExecuteReaderAsync()) { if (!await reader.ReadAsync()) { return(null); } var headers = reader["headers"]; var headersDictionary = _headerSerializer.Deserialize((byte[])headers); idOfMessageToDelete = (long)reader["id"]; var body = (byte[])reader["body"]; receivedTransportMessage = new TransportMessage(headersDictionary, body); } } if (!idOfMessageToDelete.HasValue) { return(null); } using (var deleteCommand = connection.CreateCommand()) { deleteCommand.CommandText = string.Format("DELETE FROM [{0}] WHERE [id] = @id", _tableName); deleteCommand.Parameters.Add("id", SqlDbType.BigInt).Value = idOfMessageToDelete; await deleteCommand.ExecuteNonQueryAsync(); } return(receivedTransportMessage); } }