public virtual void Initialize(Transmitter transmitter)
{
if (transmitter == null)
{
throw new ArgumentNullException("transmitter");
}
this.Transmitter = transmitter;
}
public TelemetrySerializer(Transmitter transmitter)
{
if (transmitter == null)
{
throw new ArgumentNullException("transmitter");
}
this.transmitter = transmitter;
}
internal ServerTelemetryChannel(INetwork network, IApplicationLifecycle applicationLifecycle)
{
var policies = new TransmissionPolicy[]
{
new ApplicationLifecycleTransmissionPolicy(applicationLifecycle),
new ErrorHandlingTransmissionPolicy(),
new NetworkAvailabilityTransmissionPolicy(network),
new ThrottlingTransmissionPolicy()
};
this.Transmitter = new Transmitter(policies: policies);
this.TelemetrySerializer = new TelemetrySerializer(this.Transmitter);
this.TelemetryBuffer = new Implementation.TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle);
this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity;
this.TelemetryProcessor = this.TelemetryBuffer;
}
public async Task StoresTransmissionWhenSenderIsFull()
{
bool isInStorage = false;
var sender = new StubTransmissionSender {
OnEnqueue = t => false
};
var buffer = new TransmissionBuffer();
var storage = new StubTransmissionStorage
{
OnEnqueue = getTransmission =>
{
isInStorage = true;
return(true);
}
};
Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer, storage: storage);
var transmission = new StubTransmission();
var result = await transmitter.FlushAsync(transmission, default);
Assert.IsTrue(isInStorage);
Assert.IsTrue(result);
}
public void MovesTransmissionsFromBufferToStorageWhenBufferCapacityIsZero()
{
var storage = new StubTransmissionStorage {
Capacity = 1
};
var bufferedTransmission = new StubTransmission();
var buffer = new TransmissionBuffer();
storage.Enqueue(() => bufferedTransmission);
var policy = new StubTransmissionPolicy();
policy.MaxBufferCapacity = 1;
Transmitter transmitter = CreateTransmitter(buffer: buffer, storage: storage, policies: new[] { policy });
policy.MaxBufferCapacity = 0;
policy.Apply();
Transmission storedTransmission = storage.Dequeue();
Assert.Same(bufferedTransmission, storedTransmission);
}
public void TransmittionIsSavedToStorageFolder()
{
var testDirectory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
testDirectory.Create();
try
{
Transmitter transmitter = new Transmitter();
transmitter.StorageFolder = testDirectory.FullName;
transmitter.MaxSenderCapacity = 0;
transmitter.MaxBufferCapacity = 0;
transmitter.Initialize();
transmitter.Enqueue(new StubTransmission());
Assert.Equal(1, testDirectory.EnumerateFiles().Count());
}
finally
{
testDirectory.Delete(true);
}
}
public void LogsUnhandledAsyncExceptionsToPreventThemFromCrashingApplication()
{
var exception = new Exception(Guid.NewGuid().ToString());
var buffer = new StubTransmissionBuffer
{
OnEnqueue = getTransmissionAsync =>
{
throw exception;
}
};
Transmitter transmitter = CreateTransmitter(buffer: buffer);
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
buffer.OnTransmissionDequeued(new TransmissionProcessedEventArgs(new StubTransmission()));
EventWrittenEventArgs message = listener.Messages.First();
Assert.Contains(exception.Message, (string)message.Payload[0], StringComparison.Ordinal);
}
}
public void BuffersTransmissionWhenSenderIsFull()
{
var sender = new StubTransmissionSender {
OnEnqueue = t => false
};
Transmission bufferedTransmission = null;
var buffer = new StubTransmissionBuffer
{
OnEnqueue = getTransmission =>
{
bufferedTransmission = getTransmission();
return(bufferedTransmission != null);
},
};
Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer);
var transmission = new StubTransmission();
transmitter.Enqueue(transmission);
Assert.Same(transmission, bufferedTransmission);
}
public void EmptiesBufferIfCapacityIsZero()
{
//// We set capacity to 0 and clear the cache when DC responds with 439.
var buffer = new StubTransmissionBuffer();
buffer.Enqueue(() => new StubTransmission());
var storage = new StubTransmissionStorage();
storage.Enqueue(() => new StubTransmission());
var sender = new StubTransmissionSender();
sender.Enqueue(() => new StubTransmission());
var policy = new StubTransmissionPolicy();
policy.MaxStorageCapacity = 0;
Transmitter transmitter = CreateTransmitter(sender, buffer, storage, new[] { policy });
policy.Apply();
Assert.Equal(0, storage.Queue.Count);
}
public override void Initialize(Transmitter transmitter)
{
base.Initialize(transmitter);
transmitter.TransmissionSent += this.HandleTransmissionSentEvent;
}
public async Task FlushAsyncRespectsCancellationToken()
{
Transmitter transmitter = CreateTransmitter();
await Assert.ThrowsExceptionAsync <TaskCanceledException>(() => transmitter.FlushAsync(new StubTransmission(), new CancellationToken(true)));
}
public virtual void Initialize(Transmitter transmitter)
{
this.Transmitter = transmitter ?? throw new ArgumentNullException(nameof(transmitter));
}
public override void Initialize(Transmitter transmitter)
{
base.Initialize(transmitter);
this.SubscribeToNetworkAddressChangedEvents();
this.SetBufferAndSenderCapacity();
}
public override void Initialize(Transmitter transmitter)
{
base.Initialize(transmitter);
transmitter.TransmissionSent += this.HandleTransmissionSentEvent;
}
public TelemetrySerializer(Transmitter transmitter) => this.Transmitter = transmitter ?? throw new ArgumentNullException(nameof(transmitter));
public override void Initialize(Transmitter transmitter)
{
this.OnInitialize(transmitter);
}
public override void Initialize(Transmitter transmitter)
{
base.Initialize(transmitter);
this.SubscribeToNetworkAddressChangedEvents();
this.SetBufferAndSenderCapacity();
}
