public void ForwardData()
{
var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null);
var handler = new DataHandler(systemDiagnostics);
var sendingEndpoint = new EndpointId("sendingEndpoint");
var filePath = GenerateNewTestFileName();
var timeout = TimeSpan.FromSeconds(30);
var task = handler.ForwardData(sendingEndpoint, filePath, timeout);
Assert.IsFalse(task.IsCompleted);
var text = "Hello world.";
var data = new MemoryStream();
var writer = new StreamWriter(data);
writer.Write(text);
writer.Flush();
data.Position = 0;
var msg = new DataTransferMessage
{
SendingEndpoint = sendingEndpoint,
Data = data,
};
handler.ProcessData(msg);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(text, new StreamReader(task.Result.FullName).ReadToEnd());
}
/// <summary>
/// Initializes a new instance of the <see cref="DataTransferEventArgs"/> class.
/// </summary>
/// <param name="data">The data.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="data"/> is <see langword="null" />.
/// </exception>
public DataTransferEventArgs(DataTransferMessage data)
{
{
Lokad.Enforce.Argument(() => data);
}
m_Data = data;
}
private void RaiseOnDataReception(DataTransferMessage message)
{
var local = OnDataReception;
if (local != null)
{
local(this, new DataTransferEventArgs(message));
}
}
public void ProcessData(DataTransferMessage message)
{
{
Lokad.Enforce.Argument(() => message);
}
m_Diagnostics.Log(
LevelToLog.Trace,
CommunicationConstants.DefaultLogTextPrefix,
string.Format(
CultureInfo.InvariantCulture,
"Received data stream from {0}.",
message.SendingEndpoint));
using (m_Diagnostics.Profiler.Measure(CommunicationConstants.TimingGroup, "Processing incoming data stream"))
{
Tuple <string, Subject <FileInfo>, CancellationTokenSource> pair = null;
lock (m_Lock)
{
if (m_TasksWaitingForData.ContainsKey(message.SendingEndpoint))
{
pair = m_TasksWaitingForData[message.SendingEndpoint];
}
}
// Invoke the SetResult outside the lock because the setting of the
// result may lead to other messages being send and more responses
// being required to be handled. All of that may need access to the lock.
if (pair != null)
{
try
{
var directory = Path.GetDirectoryName(pair.Item1);
if ((directory != null) && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using (var fileStream = new FileStream(pair.Item1, FileMode.Create, FileAccess.Write, FileShare.None))
{
message.Data.CopyTo(fileStream);
}
pair.Item2.OnNext(new FileInfo(pair.Item1));
pair.Item2.OnCompleted();
}
catch (Exception e)
{
pair.Item2.OnError(e);
}
}
}
}
/// <summary>
/// Transfers the stream to the given endpoint.
/// </summary>
/// <param name="endpoint">The endpoint to which the data should be send.</param>
/// <param name="data">The data to be send.</param>
/// <param name="maximumNumberOfRetries">The maximum number of times the endpoint will try to transfer the data if delivery fails.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="endpoint"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="data"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if <paramref name="maximumNumberOfRetries"/> is smaller than 1.
/// </exception>
public void Send(ProtocolInformation endpoint, Stream data, int maximumNumberOfRetries)
{
{
Lokad.Enforce.Argument(() => endpoint);
Lokad.Enforce.Argument(() => data);
Lokad.Enforce.With <ArgumentOutOfRangeException>(
maximumNumberOfRetries > 0,
Resources.Exceptions_Messages_NumberOfRetriesShouldBeLargerThanZero);
}
var channel = DataChannelFor(endpoint);
var msg = new DataTransferMessage
{
SendingEndpoint = m_LocalEndpoint,
Data = data,
};
channel.Send(msg, maximumNumberOfRetries);
}
public void OnDataReception()
{
var id = new EndpointId("a");
var template = new Mock <IProtocolChannelTemplate>();
var messageUri = new Uri("http://localhost/messages/invalid");
var dataUri = new Uri("http://localhost/data/invalid");
var host = new Mock <IHoldServiceConnections>();
{
host.Setup(
h =>
h.OpenChannel(
It.IsAny <IReceiveInformationFromRemoteEndpoints>(),
It.IsAny <Func <ServiceHost, ServiceEndpoint> >()))
.Returns <IReceiveInformationFromRemoteEndpoints, Func <ServiceHost, ServiceEndpoint> >(
(r, f) => r is IMessagePipe ? messageUri : dataUri)
.Verifiable();
}
Func <IHoldServiceConnections> hostBuilder = () => host.Object;
var messagePipe = new Mock <IMessagePipe>();
Func <Version, Tuple <Type, IMessagePipe> > messageReceiverBuilder =
version => new Tuple <Type, IMessagePipe>(typeof(IMessagePipe), messagePipe.Object);
var dataPipe = new Mock <IDataPipe>();
Func <Version, Tuple <Type, IDataPipe> > dataReceiverBuilder =
version => new Tuple <Type, IDataPipe>(typeof(IDataPipe), dataPipe.Object);
var sendingEndpoint = new Mock <ISendingEndpoint>();
BuildSendingEndpoint senderBuilder = (endpoint, builder, endpointBuilder) => sendingEndpoint.Object;
var messageEndpoint = new Mock <IMessageSendingEndpoint>();
Func <Version, Uri, IMessageSendingEndpoint> versionedMessageSenderBuilder = (version, uri) => messageEndpoint.Object;
var dataEndpoint = new Mock <IDataTransferingEndpoint>();
Func <Version, Uri, IDataTransferingEndpoint> versionedDataSenderBuilder = (version, uri) => dataEndpoint.Object;
var channel = new ProtocolChannel(
id,
template.Object,
hostBuilder,
messageReceiverBuilder,
dataReceiverBuilder,
senderBuilder,
versionedMessageSenderBuilder,
versionedDataSenderBuilder);
var eventWasRaised = false;
var msg = new DataTransferMessage();
channel.OnDataReception +=
(s, e) =>
{
eventWasRaised = true;
Assert.AreEqual(msg, e.Data);
};
channel.OpenChannel();
var protocols = channel.LocalConnectionPoints().ToList();
Assert.AreEqual(1, protocols.Count());
dataPipe.Raise(m => m.OnNewData += null, new DataTransferEventArgs(msg));
Assert.IsTrue(eventWasRaised);
}
