public void SynchronizeAllExceptOneScheduledJobs()
{
var scheduleJobRepo = new Mock <IScheduledJobRepository>();
var configReader = new Mock <IConfigurationReader>();
scheduleJobRepo.Setup(x => x.List()).Returns(ListOfScheduledJobs);
var syncData = new SynchronizationData();
syncData.RunAsInitializationModule = false;
syncData.RunInitializationModuleEveryStartup = false;
syncData.ScheduledJobs = new List <ScheduledJobDefinition>();
syncData.ScheduledJobs.Add(new ScheduledJobDefinition {
Id = "*", IsEnabled = true, Name = string.Empty
});
syncData.ScheduledJobs.Add(new ScheduledJobDefinition {
Id = "147f865b-3360-4804-9640-81e5cfe1d56c", IsEnabled = false, Name = string.Empty
});
configReader.Setup(x => x.ReadConfiguration()).Returns(syncData);
var scheduledJobSynchronizer = new ScheduledJobSynchronizer(scheduleJobRepo.Object, configReader.Object);
var environmentName = "environmentTest";
var resultLog = scheduledJobSynchronizer.Synchronize(environmentName);
Assert.IsTrue(resultLog.Contains("Set Test (5c7d4c45-2e67-4275-a567-e7b6c98429c2) to IsEnabled=True."));
Assert.IsTrue(resultLog.Contains("Set Test2 (147f865b-3360-4804-9640-81e5cfe1d56c) to IsEnabled=False."));
}
public void SynchronizeNoneScheduledJobs()
{
var scheduleJobRepo = new Mock <IScheduledJobRepository>();
var scheduleJobExecutor = new Mock <IScheduledJobExecutor>();
var configReader = new Mock <IConfigurationReader>();
scheduleJobRepo.Setup(x => x.List()).Returns(ListOfScheduledJobs);
var syncData = new SynchronizationData();
syncData.RunAsInitializationModule = false;
syncData.RunInitializationModuleEveryStartup = false;
syncData.ScheduledJobs = new List <ScheduledJobDefinition>();
syncData.ScheduledJobs.Add(new ScheduledJobDefinition {
Id = "xxx", IsEnabled = true, Name = "Wrong"
});
configReader.Setup(x => x.ReadConfiguration()).Returns(syncData);
var scheduledJobSynchronizer = new ScheduledJobSynchronizer(scheduleJobRepo.Object, scheduleJobExecutor.Object, configReader.Object);
var environmentName = "environmentTest";
var resultLog = scheduledJobSynchronizer.Synchronize(environmentName);
Assert.IsTrue(resultLog.Contains("Could not find scheduled job with id=\"xxx\" name=\"Wrong\""));
}
public void SynchronizeOneScheduledJob_WithAutoRun()
{
var scheduleJobRepo = new Mock <IScheduledJobRepository>();
var scheduleJobExecutor = new Mock <IScheduledJobExecutor>();
var configReader = new Mock <IConfigurationReader>();
scheduleJobRepo.Setup(x => x.List()).Returns(ListOfScheduledJobs);
var syncData = new SynchronizationData();
syncData.RunAsInitializationModule = false;
syncData.RunInitializationModuleEveryStartup = false;
syncData.ScheduledJobs = new List <ScheduledJobDefinition>();
syncData.ScheduledJobs.Add(new ScheduledJobDefinition {
Id = "5c7d4c45-2e67-4275-a567-e7b6c98429c2", IsEnabled = true, Name = "Test", AutoRun = true
});
configReader.Setup(x => x.ReadConfiguration()).Returns(syncData);
var scheduledJobSynchronizer = new ScheduledJobSynchronizer(scheduleJobRepo.Object, scheduleJobExecutor.Object, configReader.Object);
var environmentName = "environmentTest";
var resultLog = scheduledJobSynchronizer.Synchronize(environmentName);
Assert.IsTrue(resultLog.Contains("Set Test (5c7d4c45-2e67-4275-a567-e7b6c98429c2) to IsEnabled=True."));
Assert.IsTrue(resultLog.Contains("Ran Test (5c7d4c45-2e67-4275-a567-e7b6c98429c2)."));
}
public void Initialize(StreamType stream)
{
_streamSyncData[(int)stream] = new SynchronizationData
{
StreamType = stream
};
}
private static bool IsTransferredDurationCompleted(SynchronizationData streamState)
{
if (streamState.SyncState == SynchronizationState.PlayerClockSynchronize)
{
return(streamState.Dts - PlayerClockProvider.LastClock >= StreamClockMaximumOverhead);
}
return(streamState.TransferredDuration >= streamState.NeededDuration);
}
public ClientApplication(UDPConnection connection, SynchronizationData synchronizationData) : base(connection, new NetworkLogger(true))
{
_synchronizationData = synchronizationData;
_synchronizationData.myMeditation.valueChanged += OnMeditationChanged;
SetMessageHandler <Ping>(OnPing);
SetMessageHandler <ConnectionResponse>(OnConnectionResponse);
SetMessageHandler <PlayerData>(OnOpponentUpdate);
}
private static Task DelayStream(SynchronizationData streamState, TimeSpan referencePosition, CancellationToken token)
{
var delay = streamState.Pts - referencePosition - StreamClockMaximumOverhead;
if (delay >= MinimumDelayDuration)
{
Logger.Info($"{streamState.StreamType}: Pts {streamState.Pts} Reference {referencePosition} Delay {delay}");
return(Task.Delay(delay, token));
}
return(Task.CompletedTask);
}
private static Task DelayStream(SynchronizationData streamState, CancellationToken token)
{
var transferTime = (DateTimeOffset.Now - streamState.BeginTime);
if (transferTime >= streamState.TransferredDuration)
{
return(Task.CompletedTask);
}
var delay = streamState.TransferredDuration - transferTime;
Logger.Info($"{streamState.StreamType}: Delaying {delay}");
return(Task.Delay(delay, token));
}
private Task SyncStream(SynchronizationData streamState, CancellationToken token)
{
var playerClock = _playerClockSource.Clock;
var targetClock = streamState.Pts - StreamClockMinimumOverhead;
if (targetClock - playerClock >= MinimumDelayDuration)
{
Logger.Info($"{streamState.StreamType}: Pts {streamState.Pts} to {playerClock} resume {targetClock}");
return(_playerClockSource.PlayerClockObservable()
.FirstAsync(pClock => pClock >= targetClock)
.ToTask(token));
}
return(Task.CompletedTask);
}
private static async Task DelayStream(SynchronizationData streamState, bool keyFramesSeen, CancellationToken token)
{
var transferTime = (streamState.EndTime - streamState.BeginTime);
if (transferTime >= streamState.TransferredDuration)
{
return;
}
var delay = streamState.TransferredDuration - transferTime;
Logger.Info($"{streamState.StreamType}: Delaying {delay}");
ResetTransferChunk(streamState, delay, keyFramesSeen);
await Task.Delay(delay, token).ConfigureAwait(false);
}
private bool IsSyncRequired(SynchronizationData streamState)
{
if (streamState.SyncState == SynchronizationState.PlayerClockSynchronize)
{
return(streamState.Pts - _playerClockSource.Clock >= StreamClockMaximumOverhead);
}
// _syncClock may not have been started yet.
if (_syncClock == null)
{
return(false);
}
// Force sync if there was none for MaximumSynchronisationInterval.
// Or if stream position is ahead of reference clock by StreamClockMaximumOverhead.
return(_syncClock.Elapsed - streamState.LastSync >= MaximumSynchronisationInterval ||
streamState.Pts - _syncClock.Position >= StreamClockMaximumOverhead);
}
private async Task StreamSync(SynchronizationData streamState, CancellationToken token)
{
var playerClock = _playerClockSource.LastClock;
var clockDiff = streamState.Pts - playerClock - StreamClockMinimumOverhead;
if (clockDiff <= TimeSpan.Zero)
{
return;
}
var desiredClock = playerClock + clockDiff;
Logger.Info($"{streamState.StreamType}: Sync {streamState.Dts} to {playerClock} Restart ({desiredClock})");
await _playerClockSource.PlayerClockObservable()
.FirstAsync(pClock => pClock >= desiredClock)
.ToTask(token)
.ConfigureAwait(false);
}
private static void UpdateTransferData(SynchronizationData streamState, Packet packet)
{
var lastClock = streamState.Dts;
streamState.Dts = packet.Dts;
streamState.Pts = packet.Pts;
var clockDiff = streamState.Dts - lastClock;
// Ignore clock discontinuities
clockDiff = clockDiff > StreamClockDiscontinuityThreshold || clockDiff <= TimeSpan.Zero
? TimeSpan.Zero : clockDiff;
streamState.TransferredDuration += clockDiff;
if (streamState.KeyFrameSeen || !packet.IsKeyFrame)
{
return;
}
streamState.KeyFrameSeen = true;
Logger.Info($"{packet.StreamType}: KeyFrame {packet.Dts}/{packet.Pts}");
}
private static void UpdateTransferredDuration(SynchronizationData streamState, Packet packet)
{
if (streamState.FirstPts == default(TimeSpan))
{
streamState.FirstPts = packet.Pts;
}
if (!streamState.IsKeyFrameSeen && packet.IsKeyFrame)
{
// On first key frame, reset transfer duration to collect KeyFrameTransferDuration ammount
// of data after key frame. Below this level, ESPlayer may not complete current async operations
// (seek/prepare)
streamState.IsKeyFrameSeen = true;
streamState.NeededDuration = streamState.TransferredDuration + KeyFrameTransferDuration;
if (packet.StreamType == StreamType.Video)
{
Logger.Info($"{streamState.StreamType}: Key frame seen. Player clock alternative set to {streamState.FirstPts}");
}
}
var lastClock = streamState.Dts;
streamState.Dts = packet.Dts;
streamState.Pts = packet.Pts;
var clockDiff = streamState.Dts - lastClock;
if (clockDiff > StreamClockDiscontinuityThreshold || clockDiff <= TimeSpan.Zero)
{
return;
}
streamState.TransferredDuration += clockDiff;
}
private Task StreamSync(SynchronizationData streamState, CancellationToken token)
{
var playerClock = PlayerClockProvider.LastClock;
if (playerClock < TimeSpan.Zero)
{
playerClock = streamState.FirstPts;
}
var clockDiff = streamState.Pts - playerClock - StreamClockMinimumOverhead;
if (clockDiff <= TimeSpan.Zero)
{
return(Task.CompletedTask);
}
var desiredClock = playerClock + clockDiff;
Logger.Info($"{streamState.StreamType}: Sync {streamState.Dts} to {playerClock} ({clockDiff}) Restart {desiredClock}");
return(_playerClockSource.PlayerClockObservable()
.FirstAsync(pClock => pClock >= desiredClock)
.ToTask(token));
}
private static void ResetTransferChunk(SynchronizationData streamState)
{
streamState.TransferredDuration = TimeSpan.Zero;
streamState.NeededDuration = DefaultTransferDuration;
streamState.BeginTime = DateTimeOffset.Now;
}
public UpdateOpponentData(SynchronizationData synchronizationData, PlayerData opponentData)
{
_synchronizationData = synchronizationData;
_opponentData = opponentData;
}
public SynchronizationData ReadConfiguration()
{
var config = new SynchronizerConfiguration();
var syncData = new SynchronizationData();
if (config.Settings == null)
{
return(syncData);
}
try
{
syncData.RunAsInitializationModule = config.Settings.RunAsInitializationModule;
syncData.RunInitializationModuleEveryStartup = config.Settings.RunInitializationModuleEveryStartup;
if (config.Settings.SiteDefinitions != null && config.Settings.SiteDefinitions.Count > 0)
{
syncData.SiteDefinitions = new List <SiteDefinition>();
foreach (SiteDefinitionElement element in config.Settings.SiteDefinitions)
{
var siteDefinition = new SiteDefinition()
{
Id = string.IsNullOrEmpty(element.Id) ? Guid.Empty : new Guid(element.Id),
Name = string.IsNullOrEmpty(element.Name) ? string.Empty : element.Name,
SiteUrl = string.IsNullOrEmpty(element.SiteUrl) ? null : new Uri(element.SiteUrl),
Hosts = element.Hosts.ToHostDefinitions()
};
if (!string.IsNullOrEmpty(siteDefinition.Name) && siteDefinition.SiteUrl != null)
{
syncData.SiteDefinitions.Add(siteDefinition);
}
}
}
else
{
Logger.Information($"Found no site definitions to handle.");
}
if (config.Settings.ScheduleJobs != null && config.Settings.ScheduleJobs.Count > 0)
{
syncData.ScheduledJobs = new List <ScheduledJobDefinition>();
foreach (ScheduledJobElement element in config.Settings.ScheduleJobs)
{
var job = new ScheduledJobDefinition
{
Id = element.Id,
Name = element.Name,
IsEnabled = element.IsEnabled
};
syncData.ScheduledJobs.Add(job);
}
}
else
{
Logger.Information($"Found no schedule jobs to handle.");
}
}
catch (Exception ex)
{
Logger.Error($"No configuration found in the web.config. Missing env.synchronizer section.", ex);
}
return(syncData);
}
private bool IsTransferredDurationCompleted(SynchronizationData streamState)
{
return((streamState.SyncState == SynchronizationState.PlayerClockSynchronize)
? streamState.Pts - _playerClockSource.LastClock >= StreamClockMaximumOverhead
: streamState.TransferredDuration >= streamState.NeededDuration);
}
public SynchronizationData ReadConfiguration()
{
var syncData = new SynchronizationData();
if (_configuration == null)
{
return(syncData);
}
try
{
syncData.RunAsInitializationModule = _configuration.RunAsInitializationModule;
syncData.RunInitializationModuleEveryStartup = _configuration.RunInitializationModuleEveryStartup;
if (_configuration.SiteDefinitions != null && _configuration.SiteDefinitions.Count > 0)
{
syncData.SiteDefinitions = new List <SiteDefinition>();
foreach (var options in _configuration.SiteDefinitions)
{
var siteDefinition = new SiteDefinition()
{
Id = string.IsNullOrEmpty(options.Id) ? Guid.Empty : new Guid(options.Id),
Name = string.IsNullOrEmpty(options.Name) ? string.Empty : options.Name,
SiteUrl = string.IsNullOrEmpty(options.SiteUrl) ? null : new Uri(options.SiteUrl),
Hosts = ToHostDefinitions(options.Hosts)
};
if (!string.IsNullOrEmpty(siteDefinition.Name) && siteDefinition.SiteUrl != null)
{
syncData.SiteDefinitions.Add(siteDefinition);
}
}
}
else
{
Logger.Information($"Found no site definitions to handle.");
}
if (_configuration.ScheduledJobs != null && _configuration.ScheduledJobs.Count > 0)
{
syncData.ScheduledJobs = new List <ScheduledJobDefinition>();
foreach (var options in _configuration.ScheduledJobs)
{
var job = new ScheduledJobDefinition
{
Id = options.Id,
Name = options.Name,
IsEnabled = options.IsEnabled,
AutoRun = options.AutoRun
};
syncData.ScheduledJobs.Add(job);
}
}
else
{
Logger.Information($"Found no schedule jobs to handle.");
}
}
catch (Exception ex)
{
Logger.Error($"No configuration found in the web.config. Missing env.synchronizer section.", ex);
}
return(syncData);
}
private static void ResetTransferChunk(SynchronizationData streamState, TimeSpan delay, bool keyFramesSeen)
{
streamState.TransferredDuration = TimeSpan.Zero;
streamState.NeededDuration = keyFramesSeen ? PostKeyFrameTransferDuration : PreKeyFrameTransferDuration;
streamState.BeginTime = DateTimeOffset.Now + delay;
}
