public void HandleResponseObserver(IMessage messageDto,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
throw new NotImplementedException();
}
/// <summary>
/// Processes a GetNeighbourResponse item from stream.
/// </summary>
/// <param name="peerNeighborsRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override PeerNeighborsResponse HandleRequest(PeerNeighborsRequest peerNeighborsRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(peerNeighborsRequest, nameof(peerNeighborsRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("PeerNeighborsRequest Message Received");
var activePeersList = _repository
.FindAll(new Specification <Peer>(p => !p.IsAwolPeer))
.Take(Constants.NumberOfRandomPeers) // 😂
.ToList();
Guard.Argument(activePeersList).MinCount(1);
var peerNeighborsResponseMessage = new PeerNeighborsResponse();
for (var i = 0; i < Constants.NumberOfRandomPeers; i++)
{
peerNeighborsResponseMessage.Peers.Add(activePeersList.RandomElement().PeerId);
}
return(peerNeighborsResponseMessage);
}
/// <summary>
///
/// </summary>
/// <param name="signMessageRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(SignMessageResponse signMessageRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(signMessageRequest, nameof(signMessageRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
Logger.Debug(@"sign message response");
try
{
var decodeResult = MultiBase.Decode(signMessageRequest.OriginalMessage.ToByteArray().ToString());
Guard.Argument(decodeResult, nameof(decodeResult)).NotNull("The sign message response cannot be null.");
var originalMessage = decodeResult.ToHexString();
Guard.Argument(originalMessage, nameof(originalMessage)).NotNull();
_output.WriteLine(
$@"Signature: {signMessageRequest.Signature.ToByteArray().ToBase32()} " +
$@"Public Key: {signMessageRequest.PublicKey.ToByteArray().ToBase32()} Original Message: {originalMessage}");
}
catch (Exception ex)
{
Logger.Error(ex,
"Failed to handle SignMessageResponseHandler after receiving message {0}", signMessageRequest);
_output.WriteLine(ex.Message);
}
finally
{
Logger.Information("Press Enter to continue ...");
}
}
protected override void HandleResponse(TransferFileBytesRequest message,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
_fileTransferFactory.DownloadChunk(message);
}
/// <summary>
///
/// </summary>
/// <param name="addFileToDfsResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(AddFileToDfsResponse addFileToDfsResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(addFileToDfsResponse, nameof(addFileToDfsResponse)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
// @TODO return int not byte
// var responseCode = Enumeration.Parse<FileTransferResponseCodes>(deserialised.ResponseCode[0].ToString());
var responseCode = (FileTransferResponseCodeTypes)addFileToDfsResponse.ResponseCode[0];
if (responseCode == FileTransferResponseCodeTypes.Successful)
{
_rpcFileTransferFactory.FileTransferAsync(correlationId, CancellationToken.None)
.ConfigureAwait(false);
}
else
{
var fileTransferInformation = _rpcFileTransferFactory.GetFileTransferInformation(correlationId);
if (fileTransferInformation != null)
{
_rpcFileTransferFactory.Remove(fileTransferInformation, true);
}
}
}
public void Init()
{
_testScheduler = new TestScheduler();
_correlationManager = Substitute.For <IPeerMessageCorrelationManager>();
_gossipManager = Substitute.For <IBroadcastManager>();
_keySigner = Substitute.For <FakeKeySigner>();
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
var peerValidator = Substitute.For <IPeerIdValidator>();
peerValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_factory = new TestPeerServerChannelFactory(
_correlationManager,
_gossipManager,
_keySigner,
peerValidator,
peerSettings,
_testScheduler);
_senderId = PeerIdHelper.GetPeerId("sender");
_correlationId = CorrelationId.GenerateCorrelationId();
_signature = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default)
.ReturnsForAnyArgs(true);
}
/// <summary>
/// Processes a GetNeighbourResponse item from stream.
/// </summary>
/// <param name="messageDto"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(PeerNeighborsResponse messageDto,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
ResponseMessageSubject.OnNext(new PeerClientMessageDto(messageDto, senderPeerId, correlationId));
}
/// <summary>
///
/// </summary>
/// <param name="getFileFromDfsResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(GetFileFromDfsResponse getFileFromDfsResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(getFileFromDfsResponse, nameof(getFileFromDfsResponse)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
var responseCode = (FileTransferResponseCodeTypes)getFileFromDfsResponse.ResponseCode[0];
var fileTransferInformation = _fileTransferFactory.GetFileTransferInformation(correlationId);
if (fileTransferInformation == null)
{
return;
}
if (responseCode == FileTransferResponseCodeTypes.Successful)
{
fileTransferInformation.SetLength(getFileFromDfsResponse.FileSize);
var ctx = new CancellationTokenSource();
_fileTransferFactory.FileTransferAsync(fileTransferInformation.CorrelationId, CancellationToken.None)?.ContinueWith(task =>
{
File.Move(fileTransferInformation.TempPath, fileTransferInformation.FileOutputPath);
}, ctx.Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
}
else
{
fileTransferInformation.Expire();
}
}
/// <summary>
///
/// </summary>
/// <param name="removePeerRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override RemovePeerResponse HandleRequest(RemovePeerRequest removePeerRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(removePeerRequest, nameof(removePeerRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("Received message of type RemovePeerRequest");
uint peerDeletedCount = 0;
var publicKeyIsEmpty = removePeerRequest.PublicKey.IsEmpty;
var peersToDelete = _peerRepository.FindAll(new Specification <Peer>(peer =>
peer.PeerId.Ip.SequenceEqual(removePeerRequest.PeerIp) &&
(publicKeyIsEmpty || peer.PeerId.PublicKey.SequenceEqual(removePeerRequest.PublicKey.ToByteArray())))).ToArray();
foreach (var peerToDelete in peersToDelete)
{
_peerRepository.Delete(peerToDelete);
peerDeletedCount += 1;
}
return(new RemovePeerResponse
{
DeletedCount = peerDeletedCount
});
}
/// <summary>
/// </summary>
/// <param name="getMempoolRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override GetMempoolResponse HandleRequest(GetMempoolRequest getMempoolRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getMempoolRequest, nameof(getMempoolRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("GetMempoolRequestHandler starting ...");
try
{
Logger.Debug("Received GetMempoolRequest message with content {0}", getMempoolRequest);
var mempoolTransactions = _mempool.Service.GetAll()
.Select(x => x.ToProtoBuff <PublicEntryDao, PublicEntry>(_mappingProvider));
return(new GetMempoolResponse
{
Transactions = { mempoolTransactions }
});
}
catch (Exception ex)
{
Logger.Error(ex,
"Failed to handle GetInfoRequest after receiving message {0}", getMempoolRequest);
return(new GetMempoolResponse());
}
}
/// <summary>
///
/// </summary>
/// <param name="signMessageRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override SignMessageResponse HandleRequest(SignMessageRequest signMessageRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(signMessageRequest, nameof(signMessageRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("received message of type SignMessageRequest");
var decodedMessage = signMessageRequest.Message.ToByteArray();
var signingContext = signMessageRequest.SigningContext;
var signature = _keySigner.Sign(decodedMessage, signingContext);
var publicKey = _keySigner.CryptoContext.GetPublicKeyFromBytes(signature.PublicKeyBytes);
Guard.Argument(signature).NotNull("Failed to sign message. The signature cannot be null.");
Guard.Argument(publicKey).NotNull("Failed to get the public key. Public key cannot be null.");
Logger.Debug("message content is {0}", signMessageRequest.Message);
return(new SignMessageResponse
{
OriginalMessage = signMessageRequest.Message,
PublicKey = signature.PublicKeyBytes.ToByteString(),
Signature = signature.SignatureBytes.ToByteString()
});
}
/// <summary>
/// Handle the request for GetPeerInfo
/// </summary>
/// <param name="getPeerInfoRequest">The request</param>
/// <param name="channelHandlerContext">The channel handler context</param>
/// <param name="senderPeerId">The sender peer identifier</param>
/// <param name="correlationId">The correlationId</param>
/// <returns>The GetPeerInfoResponse</returns>
protected override GetPeerInfoResponse HandleRequest(GetPeerInfoRequest getPeerInfoRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getPeerInfoRequest, nameof(getPeerInfoRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("received message of type GetPeerInfoRequest");
var ip = getPeerInfoRequest.Ip;
var peerInfo = _peerRepository.GetPeersByIpAndPublicKey(ip, getPeerInfoRequest.PublicKey)
.Select(x =>
new PeerInfo
{
PeerId = x.PeerId,
Reputation = x.Reputation,
IsBlacklisted = x.BlackListed,
IsUnreachable = x.IsAwolPeer,
InactiveFor = x.InactiveFor.ToDuration(),
LastSeen = x.LastSeen.ToTimestamp(),
Modified = x.Modified?.ToTimestamp(),
Created = x.Created.ToTimestamp()
}).ToList();
var response = new GetPeerInfoResponse();
response.PeerInfo.AddRange(peerInfo);
return(response);
}
/// <inheritdoc />
public T GetFileTransferInformation(ICorrelationId key)
{
lock (_lockObject)
{
return(!_pendingFileTransfers.ContainsKey(key.Id) ? default : _pendingFileTransfers[key.Id]);
}
}
protected override void HandleResponse(SetPeerDataFolderResponse setPeerDataFolderResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
//Overriden code
}
/// <summary>
///
/// </summary>
/// <param name="getFileFromDfsResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(GetFileFromDfsResponse getFileFromDfsResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(getFileFromDfsResponse, nameof(getFileFromDfsResponse)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
// @TODO return int not byte
// var responseCode = Enumeration.Parse<FileTransferResponseCodes>(deserialised.ResponseCode[0].ToString());
var responseCode = (FileTransferResponseCodeTypes)getFileFromDfsResponse.ResponseCode[0];
var fileTransferInformation = _fileTransferFactory.GetFileTransferInformation(correlationId);
if (fileTransferInformation == null)
{
return;
}
if (responseCode == FileTransferResponseCodeTypes.Successful)
{
fileTransferInformation.SetLength(getFileFromDfsResponse.FileSize);
_fileTransferFactory.FileTransferAsync(fileTransferInformation.CorrelationId, CancellationToken.None).ContinueWith(task =>
{
File.Move(fileTransferInformation.TempPath, fileTransferInformation.FileOutputPath);
}).ConfigureAwait(false);
}
else
{
fileTransferInformation.Expire();
}
}
/// <summary>
/// Creates a new instance of <see cref="IReceivedMessageInternal"/>
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <returns></returns>
public IReceivedMessageInternal Create(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => message, message);
Guard.NotNull(() => correlationId, correlationId);
return new ReceivedMessageInternal(message, messageId, correlationId);
}
public static ProtocolMessage ToSignedProtocolMessage(this IMessage proto,
PeerId senderId,
ISignature signature = default,
SigningContext signingContext = default,
ICorrelationId correlationId = default)
{
return(ToSignedProtocolMessage(proto, senderId, signature?.SignatureBytes, signingContext, correlationId));
}
public PeerClientMessageDto(IMessage message, PeerId sender, ICorrelationId correlationId)
{
Guard.Argument(message, nameof(message))
.Require(message.GetType().Namespace.Contains("IPPN"));
Message = message;
Sender = sender;
CorrelationId = correlationId;
}
/// <summary>
/// Initializes a new instance of the <see cref="SentMessage"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public SentMessage(IMessageId messageId, ICorrelationId correlationId)
{
//NOTE - null messageID's are allowed, as this indicates a failure by the transport to send
Guard.NotNull(() => correlationId, correlationId);
MessageId = messageId;
CorrelationId = correlationId;
}
/// <summary>
/// Initializes a new instance of the <see cref="SentMessage"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public SentMessage(IMessageId messageId, ICorrelationId correlationId)
{
//NOTE - null messageID's are allowed, as this indicates a failure by the transport to send
Guard.NotNull(() => correlationId, correlationId);
MessageId = messageId;
CorrelationId = correlationId;
}
protected override void HandleResponse(PingResponse pingResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
ResponseMessageSubject.OnNext(new PeerClientMessageDto(pingResponse, senderPeerId, correlationId));
_peerChallenger.ChallengeResponseMessageStreamer.OnNext(new PeerChallengerResponse(senderPeerId));
}
/// <summary>
/// Stub Handle Response
/// </summary>
/// <param name="testResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(VersionResponse testResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
/* Empty method as this is a Stub class for testing base */
throw new NotSupportedException();
}
public Neighbour(PeerId peerId,
NeighbourStateTypes stateTypes = default,
ICorrelationId discoveryPingCorrelationId = default)
{
PeerId = peerId;
StateTypes = stateTypes ?? NeighbourStateTypes.NotContacted;
DiscoveryPingCorrelationId = discoveryPingCorrelationId;
}
/// <summary>Ensures the key exists.</summary>
/// <param name="guid">The unique identifier.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">The specified key does not exist inside the factory.</exception>
protected bool EnsureKeyExists(ICorrelationId guid)
{
if (GetFileTransferInformation(guid) == null)
{
throw new InvalidOperationException("The specified key does not exist inside the factory.");
}
return(true);
}
private ProtocolMessage GenerateProtocolMessage(ICorrelationId correlationId = null)
{
return(new AddFileToDfsRequest
{
Node = "node1",
FileName = "Test.dat",
FileSize = 10000
}.ToProtocolMessage(_senderIdentifier, correlationId));
}
/// <summary>
///
/// </summary>
/// <param name="verifyMessageResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(VerifyMessageResponse verifyMessageResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(verifyMessageResponse, nameof(verifyMessageResponse)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
}
/// <summary>
///
/// </summary>
/// <param name="versionResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(VersionResponse versionResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(versionResponse, nameof(versionResponse)).NotNull("The VersionResponse cannot be null")
.Require(d => d.Version != null,
d => $"{nameof(versionResponse)} must have a valid Version.");
}
/// <summary>
/// </summary>
/// <param name="getMempoolResponse"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(GetMempoolResponse getMempoolResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(getMempoolResponse, nameof(getMempoolResponse))
.NotNull("The GetMempoolResponse cannot be null")
.Require(d => d.Transactions != null,
d => $"{nameof(getMempoolResponse)} must have a valid Mempool.");
}
protected override void HandleResponse(DeltaHistoryResponse deltaHeightResponse,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
ResponseMessageSubject.OnNext(new PeerClientMessageDto(deltaHeightResponse, senderPeerId, correlationId));
//_deltaHistoryRequest.DeltaHistoryResponseMessageStreamer
// .OnNext(new PeerDeltaHistoryResponse(senderPeerId, deltaHeightResponse.Result));
}
/// <summary>Removes the specified unique identifier.</summary>
/// <param name="key">The unique identifier.</param>
private void Remove(ICorrelationId key)
{
lock (_lockObject)
{
if (_pendingFileTransfers.ContainsKey(key.Id))
{
_pendingFileTransfers.Remove(key.Id);
}
}
}
public void HandleResponseObserver(IMessage message,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Guard.Argument(message, nameof(message)).NotNull("The message cannot be null");
HandleResponse((TProto)message, channelHandlerContext, senderPeerId, correlationId);
}
protected override BroadcastRawTransactionResponse HandleRequest(BroadcastRawTransactionRequest messageDto,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
var responseCode = _transactionReceivedEvent.OnTransactionReceived(messageDto.Transaction.ToProtocolMessage(senderPeerId, correlationId));
return(new BroadcastRawTransactionResponse {
ResponseCode = responseCode
});
}
/// <summary>
/// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public ReceivedMessageInternal(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => message, message);
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => correlationId, correlationId);
Body = message.Body;
MesssageId = messageId;
CorrelationId = correlationId;
Headers = new ReadOnlyDictionary<string, object>(message.Headers.ToDictionary(entry => entry.Key,
entry => entry.Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="messagePayload">The raw message payload.</param>
/// <param name="headerPayload">The raw header payload.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
public PoisonMessageException(IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload, string format, params object[] args)
: base(string.Format(format, args), messageId, correlationId)
{
MessagePayload = messagePayload;
HeaderPayload = headerPayload;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="inner">The inner.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="messagePayload">The raw message payload.</param>
/// <param name="headerPayload">The raw header payload.</param>
public PoisonMessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload)
: base(message, inner, messageId, correlationId)
{
MessagePayload = messagePayload;
HeaderPayload = headerPayload;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="inner">The inner.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public MessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId)
: base(message, inner)
{
MessageId = messageId;
CorrelationId = correlationId;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
public MessageException(IMessageId messageId, ICorrelationId correlationId, string format, params object[] args)
: base(string.Format(format, args))
{
MessageId = messageId;
CorrelationId = correlationId;
}
