// 데이터를 서버로 전송(UDP)
public int SendUnreliable <T>(IPacket <T> packet)
{
int sendSize = 0;
if (transportUDP != null)
{
// 헤더 정보 생성
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
// FIX THIS : 명시적 형변환 해줌. 소스코드와 다름
header.packetId = (int)packet.GetPacketId();
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] packetData = packet.GetData();
byte[] data = new byte[headerData.Length + packetData.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
sendSize = transportUDP.Send(data, data.Length);
}
return(sendSize);
}
// 데이터를 서버로 전송(TCP)
public int SendReliable <T>(IPacket <T> packet)
{
int sendSize = 0;
if (transportTCP != null)
{
// 모듈에서 사용할 헤더 정보를 생성합니다.
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
//packetid = skill, moving 등등 moving은 2
header.packetId = (int)packet.GetPacketId();
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] packetData = packet.GetData(); //움직임 정보 들은 데이터
byte[] data = new byte[headerData.Length + packetData.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
string str = "Send reliable packet[" + header.packetId + "]";
sendSize = transportTCP.Send(data, data.Length);
}
return(sendSize);
}
//데이타를 전송하는 메소드. byte[] msg 를 newIPEndPoint로 전송한다.
public void DataSend()
{
if (sendMsgs.Count > 0)
{
DataPacket packet;
lock (sendLock)
{
packet = sendMsgs.Dequeue();
}
Debug.Log("메시지 보냄 : " + packet.endPoint);
Debug.Log("메시지 보냄 (길이) : " + packet.headerData.length);
Debug.Log("메시지 보냄 (출처) : " + packet.headerData.source);
Debug.Log("메시지 보냄 (타입) : " + packet.headerData.id);
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.Serialize(packet.headerData);
byte[] header = headerSerializer.GetSerializedData();
byte[] msg = CombineByte(header, packet.msg);
if (packet.headerData.source == (byte)DataHandler.Source.ClientSource)
{
udpSock.BeginSendTo(msg, 0, msg.Length, SocketFlags.None, packet.endPoint, new AsyncCallback(SendData), null);
}
else if (packet.headerData.source == (byte)DataHandler.Source.ServerSource)
{
tcpSock.Send(msg, 0, msg.Length, SocketFlags.None);
}
}
}
private byte[] CreatePacket <T>(IPacket <T> packet) // 패킷 만드는 메서드
{
byte[] packetData = packet.GetPacketData(); // 패킷의 데이터를 바이트화
// 헤더 생성
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
header.length = (short)packetData.Length; // 패킷 데이터의 길이를 헤더에 입력
header.id = (byte)packet.GetPacketId(); // 패킷 데이터에서 ID를 가져와 헤더에 입력
//Debug.Log("패킷 전송 - id : " + header.id.ToString() + " length :" + header.length);
byte[] headerData = null;
if (serializer.Serialize(header) == false)
{
return(null);
}
headerData = serializer.GetSerializedData(); // 헤더 데이터를 패킷 바이트로 변환
byte[] data = new byte[headerData.Length + header.length]; // 최종 패킷의 길이 = 헤더패킷길이+내용패킷길이
// 헤더와 내용을 하나의 배열로 복사
int headerSize = Marshal.SizeOf(header.id) + Marshal.SizeOf(header.length);
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
return(data);
}
public int Send <T>(int node, PacketId id, IPacket <T> packet)
{
int sendSize = 0;
if (m_sessionTcp != null)
{
// 모듈에서 사용하는 헤더 정보 생성.
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
header.packetId = id;
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] packetData = packet.GetData();
byte[] data = new byte[headerData.Length + packetData.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
//string str = "Send Packet[" + id + "]";
sendSize = m_sessionTcp.Send(node, data, data.Length);
}
return(sendSize);
}
// private method
// create packet include header
private byte[] CreatePacketStream <T, U>(Packet <T, U> packet)
{
// data iniialize
byte[] packetData = packet.GetPacketData();
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
// set header data
header.length = (short)packetData.Length;
header.id = (byte)packet.GetPacketID();
byte[] headerData = null;
try
{
serializer.Serialize(header);
}
catch
{
}
headerData = serializer.GetSerializeData();
// header / packet data combine
byte[] data = new byte[headerData.Length + packetData.Length];
int headerSize = Marshal.SizeOf(header.id) + Marshal.SizeOf(header.length);
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
return(data);
}
public int SendUnreliable <T>(IPacket <T> packet)
{
int sendSize = 0;
if (m_udp != null)
{
// 모듈에서 사용할 헤더 정보를 생성합니다.
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
header.packetId = packet.GetPacketId();
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] packetData = packet.GetData();
byte[] data = new byte[headerData.Length + packetData.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, data, 0, headerSize);
Buffer.BlockCopy(packetData, 0, data, headerSize, packetData.Length);
sendSize = m_udp.Send(data, data.Length);
}
return(sendSize);
}
/// <inheritdoc />
public Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
var headers = message.Headers;
var now = _rebusTime.Now;
var priority = headers.GetMessagePriority();
var visible = headers.GetInitialVisibilityDelay(now);
var ttl = headers.GetTtlSeconds();
var serializedHeaders = HeaderSerializer.Serialize(headers);
var command = context.GetSendCommand(_factory, _sendSql);
// Lock is blocking, but we're not async anyway (Oracle provider is blocking).
// As a bonus:
// (1) Monitor is faster than SemaphoreSlim when there's no contention, which is usually the case;
// (2) we don't need to allocate any extra object (command is private and not exposed to end-users).
lock (command)
{
new SendCommand(command)
{
Recipient = destinationAddress,
Headers = serializedHeaders,
Body = message.Body,
Priority = priority,
Now = now,
Visible = visible,
TtlSeconds = ttl,
}
.ExecuteNonQuery();
}
return(Task.CompletedTask);
}
public void Can_round_trip_headers()
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
Assert.Ignore("ApprovalTests only works on Windows");
}
var input = new Dictionary <string, string>
{
{
"key 1",
"value 1"
},
{
"key 2",
"value 2"
}
};
var serialized = HeaderSerializer.Serialize(input);
TestApprover.Verify(serialized);
var deserialize = HeaderSerializer.Deserialize(serialized);
CollectionAssert.AreEquivalent(input, deserialize);
}
public void SendReliableToAll(PacketId id, byte[] data)
{
if (m_tcp != null)
{
// 모듈에서 사용할 헤더 정보를 생성합니다.
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
header.packetId = id;
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] pdata = new byte[headerData.Length + data.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, pdata, 0, headerSize);
Buffer.BlockCopy(data, 0, pdata, headerSize, data.Length);
string str = "Send reliable packet[" + header.packetId + "]";
int sendSize = m_tcp.Send(pdata, pdata.Length);
if (sendSize < 0)
{
// 송신 오류.
}
}
}
public int Send(PacketId id, byte[] data)
{
int sendSize = 0;
if (m_tcp != null)
{
// 모듈에서 사용할 헤더 정보를 생성합니다.
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
header.packetId = id;
byte[] headerData = null;
if (serializer.Serialize(header) == true)
{
headerData = serializer.GetSerializedData();
}
byte[] packetData = new byte[headerData.Length + data.Length];
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
Buffer.BlockCopy(headerData, 0, packetData, 0, headerSize);
Buffer.BlockCopy(data, 0, packetData, headerSize, data.Length);
sendSize = m_tcp.Send(data, data.Length);
}
return(sendSize);
}
public Task Dispatch(TransportOperations outgoingMessages, TransportTransaction transaction, ContextBag context)
{
foreach (var operation in outgoingMessages.UnicastTransportOperations)
{
var serializedHeaders = HeaderSerializer.Serialize(operation.Message.Headers);
var transportSettings = _settings.getTransportSettings();
var queueIndex = operation.Destination.IndexOf("@", StringComparison.Ordinal);
string to;
string subject;
if (queueIndex > 0)
{
to = operation.Destination.Substring(queueIndex + 1);
subject = $"NSB-MSG-{operation.Destination.Substring(0, queueIndex)}-{operation.Message.MessageId}";
}
else
{
to = transportSettings.ImapUser;
subject = $"NSB-MSG-{operation.Destination}-{operation.Message.MessageId}";
}
SmtpUtils.SendMail(
transportSettings.SmtpServer,
transportSettings.SmtpServerPort,
transportSettings.SmtpUser,
transportSettings.SmtpPassword,
transportSettings.ImapUser,
to,
subject,
serializedHeaders,
operation.Message.Body);
}
return(Task.CompletedTask);
}
public Task Dispatch(TransportOperations outgoingMessages, TransportTransaction transaction, ContextBag context)
{
foreach (var operation in outgoingMessages.UnicastTransportOperations)
{
var basePath = BaseDirectoryBuilder.BuildBasePath(operation.Destination);
var nativeMessageId = Guid.NewGuid().ToString();
var bodyPath = Path.Combine(basePath, ".bodies", $"{nativeMessageId}.xml");
var dir = Path.GetDirectoryName(bodyPath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.WriteAllBytes(bodyPath, operation.Message.Body);
var messageContents = new List <string>
{
bodyPath,
HeaderSerializer.Serialize(operation.Message.Headers)
};
var messagePath = Path.Combine(basePath, $"{nativeMessageId}.txt");
// write to temp file first so an atomic move can be done
// this avoids the file being locked when the receiver tries to process it
var tempFile = Path.GetTempFileName();
File.WriteAllLines(tempFile, messageContents);
File.Move(tempFile, messagePath);
}
return(TaskEx.CompletedTask);
}
public void DataHandle()
{
if (receiveMsgs.Count != 0)
{
//패킷을 Dequeue 한다 패킷 : 메시지 타입 + 메시지 내용
tcpPacket = receiveMsgs.Dequeue();
//타입과 내용을 분리한다
msgType = tcpPacket.msg [0];
msg = new byte[tcpPacket.msg.Length - 1];
Array.Copy(tcpPacket.msg, 1, msg, 0, msg.Length);
//Dictionary에 등록된 델리게이트형 메소드에서 msg를 반환받는다.
RecvNotifier recvNotifier;
HeaderSerializer serializer = new HeaderSerializer();
HeaderData headerData = new HeaderData();
if (m_notifier.TryGetValue(msgType, out recvNotifier))
{
//send 할 id를 반환받음
headerData.id = (byte)recvNotifier(msg);
}
else
{
Console.WriteLine("DataHandler::TryGetValue 에러" + msgType);
headerData.id = (byte)ServerPacketId.None;
}
//상대방에게서 게임종료 패캣이 왔을 때는 따로 Send하지 않기 위해서
if (headerData.id == (byte)ServerPacketId.None)
{
return;
}
//send할 메시지의 길이를 받음
headerData.length = (short)msg.Length;
//헤더 serialize
try
{
serializer.Serialize(headerData);
header = serializer.GetSerializedData();
}
catch
{
Console.WriteLine("DataHandler::HeaderSerialize 에러");
}
//헤더와 메시지 내용을 합쳐서 Send
paket = CombineByte(header, msg);
tcpPacket = new TcpPacket(paket, tcpPacket.client);
lock (sendLock)
{
sendMsgs.Enqueue(tcpPacket);
}
}
}
byte[] CreateResultPacket(byte[] msg, ServerPacketId Id)
{
HeaderData headerData = new HeaderData();
HeaderSerializer HeaderSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
headerData.length = (short)msg.Length;
HeaderSerializer.Serialize(headerData);
msg = CombineByte(HeaderSerializer.GetSerializedData(), msg);
return(msg);
}
/// <summary>
/// Performs persistence of a message to the underlying table
/// </summary>
/// <param name="destinationAddress">Address the message will be sent to</param>
/// <param name="message">Message to be sent</param>
/// <param name="connection">Connection to use for writing to the database</param>
protected async Task InnerSend(string destinationAddress, TransportMessage message, IDbConnection connection)
{
var sendTable = TableName.Parse(destinationAddress);
await myLock.WaitAsync(TimeSpan.FromSeconds(5));
try
{
using (var command = connection.CreateCommand())
{
command.CommandText = $@"
INSERT INTO {sendTable.QualifiedName}
(
[headers],
[body],
[priority],
[visible],
[expiration]
)
VALUES
(
@headers,
@body,
@priority,
dateadd(ms, @visibilemilliseconds, dateadd(ss, @visibiletotalseconds, sysdatetimeoffset())),
dateadd(ms, @ttlmilliseconds, dateadd(ss, @ttltotalseconds, sysdatetimeoffset()))
)";
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var visible = GetInitialVisibilityDelay(headers);
var ttl = GetTtl(headers);
// must be last because the other functions on the headers might change them
var serializedHeaders = HeaderSerializer.Serialize(headers);
command.Parameters.Add("headers", SqlDbType.VarBinary, MathUtil.GetNextPowerOfTwo(serializedHeaders.Length)).Value = serializedHeaders;
command.Parameters.Add("body", SqlDbType.VarBinary, MathUtil.GetNextPowerOfTwo(message.Body.Length)).Value = message.Body;
command.Parameters.Add("priority", SqlDbType.Int).Value = priority;
command.Parameters.Add("visibiletotalseconds", SqlDbType.Int).Value = (int)visible.TotalSeconds;
command.Parameters.Add("visibilemilliseconds", SqlDbType.Int).Value = visible.Milliseconds;
command.Parameters.Add("ttltotalseconds", SqlDbType.Int).Value = (int)ttl.TotalSeconds;
command.Parameters.Add("ttlmilliseconds", SqlDbType.Int).Value = ttl.Milliseconds;
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
finally
{
myLock.Release();
}
}
public void DataRequest(ClientPacketId Id)
{
//No Packet
HeaderData headerData = new HeaderData();
HeaderSerializer HeaderSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
HeaderSerializer.Serialize(headerData);
byte[] msg = HeaderSerializer.GetSerializedData();
sendMsg.Enqueue(msg);
}
public static byte[] CreateResultPacket(byte[] msg, P2PPacketId Id)
{
HeaderData headerData = new HeaderData();
HeaderSerializer HeaderSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
headerData.source = (byte)DataHandler.Source.ClientSource;
headerData.length = (short)msg.Length;
HeaderSerializer.Serialize(headerData);
msg = DataHandler.CombineByte(HeaderSerializer.GetSerializedData(), msg);
return(msg);
}
private void SendToFailoverQueue(TransportMessage transportMessage, string destination)
{
Message toSend = new Message();
if (transportMessage.Body == null && transportMessage.BodyStream != null)
{
toSend.BodyStream = transportMessage.BodyStream;
}
else
{
MessageSerializer.Serialize(transportMessage.Body, toSend.BodyStream);
}
if (transportMessage.CorrelationId != null)
{
toSend.CorrelationId = transportMessage.CorrelationId;
}
else
{
toSend.CorrelationId = toSend.Id;
transportMessage.CorrelationId = toSend.Id;
transportMessage.IdForCorrelation = toSend.Id;
}
toSend.Recoverable = transportMessage.Recoverable;
toSend.ResponseQueue = new MessageQueue(GetFullPath(transportMessage.ReturnAddress));
FillLabel(toSend, transportMessage);
if (transportMessage.TimeToBeReceived < MessageQueue.InfiniteTimeout)
{
toSend.TimeToBeReceived = transportMessage.TimeToBeReceived;
}
if (transportMessage.Headers == null)
{
transportMessage.Headers = new List <HeaderInfo>();
}
transportMessage.Headers.Add(new HeaderInfo {
Key = "destination", Value = destination
});
if (transportMessage.Headers != null && transportMessage.Headers.Count > 0)
{
MemoryStream stream = new MemoryStream();
HeaderSerializer.Serialize(stream, transportMessage.Headers);
toSend.Extension = stream.GetBuffer();
}
FailoverQueue.Send(toSend, GetTransactionTypeForSend());
}
byte[] CreateHeader <T>(IPacket <T> data, ClientPacketId Id)
{
byte[] msg = data.GetPacketData();
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
headerData.length = (short)msg.Length;
headerSerializer.Serialize(headerData);
byte[] header = headerSerializer.GetSerializedData();
return(header);
}
public void Logout()
{
//No Packet
Debug.Log("로그아웃");
HeaderData headerData = new HeaderData();
HeaderSerializer HeaderSerializer = new HeaderSerializer();
headerData.Id = (byte)ClientPacketId.Logout;
HeaderSerializer.Serialize(headerData);
byte[] msg = HeaderSerializer.GetSerializedData();
sendMsg.Enqueue(msg);
StartCoroutine(loadingManager.LoadScene(GameManager.Scene.Wait, GameManager.Scene.Login, 1.0f));
}
/// <inheritdoc />
public async Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
using (await _sendBottleneck.Enter(CancellationToken.None))
{
var connection = await GetConnection(context);
using (var command = connection.CreateCommand())
{
command.CommandText = $@"
INSERT INTO {_tableName}
(
recipient,
headers,
body,
priority,
visible,
expiration
)
VALUES
(
@recipient,
@headers,
@body,
@priority,
clock_timestamp() + @visible,
clock_timestamp() + @ttlseconds
)";
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var initialVisibilityDelay = new TimeSpan(0, 0, 0, GetInitialVisibilityDelay(headers));
var ttlSeconds = new TimeSpan(0, 0, 0, GetTtlSeconds(headers));
// must be last because the other functions on the headers might change them
var serializedHeaders = HeaderSerializer.Serialize(headers);
command.Parameters.Add("recipient", NpgsqlDbType.Text).Value = destinationAddress;
command.Parameters.Add("headers", NpgsqlDbType.Bytea).Value = serializedHeaders;
command.Parameters.Add("body", NpgsqlDbType.Bytea).Value = message.Body;
command.Parameters.Add("priority", NpgsqlDbType.Integer).Value = priority;
command.Parameters.Add("visible", NpgsqlDbType.Interval).Value = initialVisibilityDelay;
command.Parameters.Add("ttlseconds", NpgsqlDbType.Interval).Value = ttlSeconds;
await command.ExecuteNonQueryAsync();
}
}
}
//패킷의 헤더 생성
byte[] CreateHeader <T>(Packet <T> data)
{
byte[] msg = data.GetPacketData();
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerData.length = (short)msg.Length;
headerData.source = (byte)NetworkManager.Source.ClientSource;
headerData.id = (byte)data.GetPacketId();
headerSerializer.Serialize(headerData);
byte[] header = headerSerializer.GetSerializedData();
return(header);
}
/// <summary>
/// Called when the transport needs to send a message to a specified destination address.
/// </summary>
/// <param name="destinationAddress"></param>
/// <param name="message"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
var connection = await GetConnection(context);
using (var command = connection.CreateCommand())
{
command.CommandText = $@"
INSERT INTO `{_tableName}`
(
`recipient`,
`headers`,
`body`,
`priority`,
`visible`,
`expiration`,
`process_id`
)
VALUES
(
@recipient,
@headers,
@body,
@priority,
date_add(now(), INTERVAL @visible SECOND),
date_add(now(), INTERVAL @ttlseconds SECOND),
NULL
);";
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var initialVisibilityDelay = GetInitialVisibilityDelay(headers);
var ttlSeconds = GetTtlSeconds(headers);
// must be last because the other functions on the headers might change them
var serializedHeaders = HeaderSerializer.Serialize(headers);
command.Parameters.Add(command.CreateParameter("recipient", DbType.String, destinationAddress));
command.Parameters.Add(command.CreateParameter("headers", DbType.Binary, serializedHeaders));
command.Parameters.Add(command.CreateParameter("body", DbType.Binary, message.Body));
command.Parameters.Add(command.CreateParameter("priority", DbType.Int32, priority));
command.Parameters.Add(command.CreateParameter("visible", DbType.Int32, initialVisibilityDelay));
command.Parameters.Add(command.CreateParameter("ttlseconds", DbType.Int32, ttlSeconds));
await command.ExecuteNonQueryAsync();
}
}
public override async Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken)
{
// indicate to the test that receive has been called - to we should now be connected
TaskCompletionSource.SetResult("ReceiveAsync");
// delay so we don't thrash, the header we return with End=false will cause an infinite receive loop
await Task.Delay(1000);
// send a valid header so we don't immediate get a deserialization exception that triggers disconnect
var header = new Header()
{
Type = PayloadTypes.Stream, Id = Guid.NewGuid(), PayloadLength = 0, End = false
};
var count = HeaderSerializer.Serialize(header, buffer.Array, buffer.Offset);
return(new WebSocketReceiveResult(count, WebSocketMessageType.Binary, true));
}
/// <summary>
/// Sends the given transport message to the specified logical destination address by adding it to the messages table.
/// </summary>
public async Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
var connection = await GetConnection(context);
using (var command = connection.CreateCommand())
{
command.CommandText = string.Format(@"
INSERT INTO [{0}]
(
[recipient],
[headers],
[body],
[priority],
[visible],
[expiration]
)
VALUES
(
@recipient,
@headers,
@body,
@priority,
dateadd(ss, @visible, getdate()),
dateadd(ss, @ttlseconds, getdate())
)",
_tableName);
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var initialVisibilityDelay = GetInitialVisibilityDelay(headers);
var ttlSeconds = GetTtlSeconds(headers);
// must be last because the other functions on the headers might change them
var serializedHeaders = _headerSerializer.Serialize(headers);
command.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = destinationAddress;
command.Parameters.Add("headers", SqlDbType.VarBinary).Value = serializedHeaders;
command.Parameters.Add("body", SqlDbType.VarBinary).Value = message.Body;
command.Parameters.Add("priority", SqlDbType.Int).Value = priority;
command.Parameters.Add("ttlseconds", SqlDbType.Int).Value = ttlSeconds;
command.Parameters.Add("visible", SqlDbType.Int).Value = initialVisibilityDelay;
await command.ExecuteNonQueryAsync();
}
}
void InnerSend(string destinationAddress, TransportMessage message, ConnectionWrapper connection)
{
using (var command = connection.Connection.CreateCommand())
{
command.CommandText = $@"
INSERT INTO {_table}
(
recipient,
headers,
body,
priority,
visible,
expiration
)
VALUES
(
:recipient,
:headers,
:body,
:priority,
:now + :visible,
:now + :ttlseconds
)";
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var initialVisibilityDelay = new TimeSpan(0, 0, 0, GetInitialVisibilityDelay(headers));
var ttlSeconds = new TimeSpan(0, 0, 0, GetTtlSeconds(headers));
// must be last because the other functions on the headers might change them
var serializedHeaders = HeaderSerializer.Serialize(headers);
command.BindByName = true;
command.Parameters.Add(new OracleParameter("recipient", OracleDbType.Varchar2, destinationAddress, ParameterDirection.Input));
command.Parameters.Add(new OracleParameter("headers", OracleDbType.Blob, serializedHeaders, ParameterDirection.Input));
command.Parameters.Add(new OracleParameter("body", OracleDbType.Blob, message.Body, ParameterDirection.Input));
command.Parameters.Add(new OracleParameter("priority", OracleDbType.Int32, priority, ParameterDirection.Input));
command.Parameters.Add(new OracleParameter("visible", OracleDbType.IntervalDS, initialVisibilityDelay, ParameterDirection.Input));
command.Parameters.Add(new OracleParameter("now", _rebusTime.Now.ToOracleTimeStamp()));
command.Parameters.Add(new OracleParameter("ttlseconds", OracleDbType.IntervalDS, ttlSeconds, ParameterDirection.Input));
command.ExecuteNonQuery();
}
}
public void HeaderSerializer_SerializesToAscii()
{
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 str = Encoding.ASCII.GetString(buffer, offset, length);
Assert.Equal("A.000168.68e999ca-a651-40f4-ad8f-3aaf781862b4.1\n", str);
}
public Task Dispatch(TransportOperations outgoingMessages, ContextBag context)
{
foreach (UnicastTransportOperation transportOperation in outgoingMessages.UnicastTransportOperations)
{
string basePath = BaseDirectoryBuilder.BuildBasePath(transportOperation.Destination);
string nativeMessageId = Guid.NewGuid().ToString();
string bodyPath = Path.Combine(basePath, ".bodies", nativeMessageId) + ".xml";
var dir = Path.GetDirectoryName(bodyPath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.WriteAllBytes(bodyPath, transportOperation.Message.Body);
List <string> messageContents = new List <string>
{
bodyPath,
HeaderSerializer.Serialize(transportOperation.Message.Headers)
};
DirectoryBasedTransaction transaction;
string messagePath = Path.Combine(basePath, nativeMessageId) + ".txt";
if (transportOperation.RequiredDispatchConsistency != DispatchConsistency.Isolated &&
context.TryGet(out transaction))
{
transaction.Enlist(messagePath, messageContents);
}
else
{
string tempFile = Path.GetTempFileName();
//write to temp file first so an atomic move can be done
//this avoids the file being locked when the receiver tries to process it
File.WriteAllLines(tempFile, messageContents);
File.Move(tempFile, messagePath);
}
}
return(TaskEx.CompletedTask);
}
/// <summary>
/// Performs persistence of a message to the underlying table
/// </summary>
/// <param name="destinationAddress">Address the message will be sent to</param>
/// <param name="message">Message to be sent</param>
/// <param name="connection">Connection to use for writing to the database</param>
protected async Task InnerSend(string destinationAddress, TransportMessage message, IDbConnection connection)
{
var sendTable = TableName.Parse(destinationAddress);
using (var command = connection.CreateCommand())
{
command.CommandText = $@"
INSERT INTO {sendTable.QualifiedName}
(
[headers],
[body],
[priority],
[visible],
[expiration]
)
VALUES
(
@headers,
@body,
@priority,
dateadd(ss, @visible, getdate()),
dateadd(ss, @ttlseconds, getdate())
)";
var headers = message.Headers.Clone();
var priority = GetMessagePriority(headers);
var initialVisibilityDelay = GetInitialVisibilityDelay(headers);
var ttlSeconds = GetTtlSeconds(headers);
// must be last because the other functions on the headers might change them
var serializedHeaders = HeaderSerializer.Serialize(headers);
command.Parameters.Add("headers", SqlDbType.VarBinary, MathUtil.GetNextPowerOfTwo(serializedHeaders.Length)).Value = serializedHeaders;
command.Parameters.Add("body", SqlDbType.VarBinary, MathUtil.GetNextPowerOfTwo(message.Body.Length)).Value = message.Body;
command.Parameters.Add("priority", SqlDbType.Int).Value = priority;
command.Parameters.Add("ttlseconds", SqlDbType.Int).Value = ttlSeconds;
command.Parameters.Add("visible", SqlDbType.Int).Value = initialVisibilityDelay;
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
