public static Container CreateContainer()
{
var container = new Container();
container.Configure(config =>
{
config.Scan(scanner =>
{
scanner.AssemblyContainingType(typeof(ChefJobRunner));
scanner.AssemblyContainingType <TimerFactory>();
scanner.WithDefaultConventions();
});
config.For <ChefJobRunner>().Singleton();
config.For <RunChefJob>().Singleton();
config.For <ChefProduct>().Singleton();
config.For <JobRunner>().Singleton();
config.For <IEnvironment>().Use <EnvironmentBoundary>();
config.For <IFileSystemCommands>().Use <FileSystemCommandsBoundary>();
config.For <IProcess>().Use <ProcessBoundary>();
config.For <IActionExecutor>().Use <RunInBackgroundActionExecutor>();
config.For <IClock>().Use(SystemClock.Instance);
config.For <IInstaller>().Use <ChefProduct>();
config.For <RunPolicy>().Use(context => RunPolicy.OnDemand());
});
return(container);
}
public decimal RunPolicy(Policy policy)
{
RunPolicy runPolicy = GetRunPolicy(policy.Type);
MessagingService.LogMessages($"Rating {Enum.GetName(typeof(PolicyType), policy.Type)} policy...", "Validating policy.");
if (runPolicy != null)
{
return(runPolicy.Start(policy));
}
;
MessagingService.LogMessages("Unknown policy type");
return(0);
}
public static void Initialize(RunChefJob runChefJob, int chefIntervalInSeconds, ITimerFactory timerFactory,
IClock clock)
{
if (chefIntervalInSeconds > 0)
{
var interval = Duration.FromSeconds(chefIntervalInSeconds);
Presenter.ShowMessage($"Scheduling chef to run every {(int) interval.TotalSeconds} seconds", Logger);
runChefJob.RunPolicy = RunPolicy.RegularlyEvery(interval, timerFactory, clock);
}
else
{
Logger.Debug(
$"Since chef interval duration is set to {chefIntervalInSeconds}, not adding chef as a recurring task");
}
}
public static RunChefJob CreateRunChefJob(IChefRunner chefRunner = null, RunPolicy runPolicy = null)
{
chefRunner = chefRunner ?? new FakeChefRunner();
runPolicy = runPolicy ?? new FakeRunPolicy();
return(new RunChefJob(runPolicy, chefRunner, new FakeClock()));
}
private RunChefJob CreateRunChefJobThatRunsJobsImmediately(IChefRunner chefRunner, RunPolicy runPolicy = null)
{
var job = CreateRunChefJob(chefRunner, runPolicy);
job.RunReady += RunJobImmediately;
return(job);
}
/// <summary>Start an infinite animation that receives time passed since previous frame rendered</summary>
public void startDelta(iDeltaTimeUpdate obj, eAnimationTimer time = eAnimationTimer.RelativeTime)
{
delta.AddOrUpdate(obj, new Animation(time));
RunPolicy.animationStarted(content);
}
/// <summary>Start an infinite animation that receives total time elapsed</summary>
public void startAbs(iAbsoluteTimeUpdate obj, eAnimationTimer time = eAnimationTimer.AbsoluteTime)
{
absolute.AddOrUpdate(obj, new Animation(time));
RunPolicy.animationStarted(content);
}
/// <summary>Start a finite animation that receives a progress value, from 0 to 1.</summary>
public void startProgress(TimeSpan duration, iAnimationProgressUpdate obj, eAnimationTimer time = eAnimationTimer.RelativeTime)
{
validateDuration(duration, true);
progress.AddOrUpdate(obj, new ProgressAnimation(time, timers[time], duration));
RunPolicy.animationStarted(content);
}
/// <summary>Start a finite animation that receives time passed since previous frame rendered</summary>
public void startDelta(TimeSpan duration, iDeltaTimeUpdate obj, eAnimationTimer time = eAnimationTimer.RelativeTime)
{
validateDuration(duration, false);
delta.AddOrUpdate(obj, new Animation(time, timers[time] + duration));
RunPolicy.animationStarted(content);
}
/// <summary>Start a finite animation that receives total time elapsed</summary>
public void startAbs(TimeSpan duration, iAbsoluteTimeUpdate obj, eAnimationTimer time = eAnimationTimer.AbsoluteTime)
{
validateDuration(duration, false);
absolute.AddOrUpdate(obj, new Animation(time, timers[time] + duration));
RunPolicy.animationStarted(content);
}
public FakeAnimation(Animations owner)
{
animations = owner;
animations.m_fakes++;
RunPolicy.animationStarted(owner.content);
}
internal void update()
{
timers.update();
bool anyLeft = false;
foreach (var kvp in absolute)
{
TimeSpan now = timers[kvp.Value.timer];
if (now < kvp.Value.finish)
{
anyLeft = true;
kvp.Key.tick(now);
continue;
}
kvp.Key.tick(kvp.Value.finish);
dropList.Add(kvp.Key);
}
foreach (iAbsoluteTimeUpdate d in dropList)
{
absolute.Remove(d);
}
dropList.Clear();
foreach (var kvp in delta)
{
kvp.Key.tick(timers.delta(kvp.Value.timer));
TimeSpan now = timers[kvp.Value.timer];
if (now < kvp.Value.finish)
{
anyLeft = true;
continue;
}
dropList.Add(kvp.Key);
}
foreach (iDeltaTimeUpdate d in dropList)
{
delta.Remove(d);
}
dropList.Clear();
foreach (var kvp in progress)
{
TimeSpan elapsed = timers[kvp.Value.timer] - kvp.Value.start;
float progress = elapsed.Ticks * kvp.Value.progressMul;
if (progress < 1)
{
anyLeft = true;
kvp.Key.tick(progress);
continue;
}
kvp.Key.tick(1);
dropList.Add(kvp.Key);
}
foreach (iAnimationProgressUpdate d in dropList)
{
progress.Remove(d);
}
dropList.Clear();
if (!anyLeft && 0 == m_fakes)
{
RunPolicy.allAnimationsFinished(content);
}
}
