private void ScheduleServiceInstance(ServiceInstance serviceInstance, TimeSpan avgExecutionTime)
{
AsLockable(serviceInstance).Unlock(_instanceLock);
serviceInstance.SchedulingInfo.SchedulingStatus = SchedulingStatus.Scheduled;
serviceInstance.StateChanged += Instance_StateChanged;
AsLockable(serviceInstance).Lock(_instanceLock);
// set service instance max execution time
serviceInstance.Configuration.Limits.MaxExecutionTime = TimeSpan.FromMilliseconds(avgExecutionTime.TotalMilliseconds * Configuration.MaxExecutionTimeFactor);
if (!_scheduledRequests.ContainsSignature(serviceInstance))
{
WriteLog(String.Format("Move unscheduled request to scheduled list '{0}'", serviceInstance.DebugInfo()));
_scheduledRequests.Add(serviceInstance);
_unscheduledRequests.Remove(serviceInstance);
}
else
{
WriteLog(String.Format("Warning! Request '{0}' already exists in scheduled list", serviceInstance.DebugInfo()), LogMessageType.Warning);
}
}
//==================================
#endregion
#region Scheduling algorithms
//==================================
/// <summary>
/// The main method of creating scheduler
/// </summary>
private void Schedule(bool reschedule = false)
{
lock (_unscheduledRequests)
{
lock (_scheduledRequests)
{
// Set need reschedule to false in order to avoid more schedule from other threads
_needReschedule = false;
#region Manage history and find services to schedule
// ------------------------------------
// Move pending uninitialized services to the unscheduled list so they can be rescheduled
foreach (ServiceInstance request in _scheduledRequests.RemoveNotActivated())
{
if (request.SchedulingInfo.RequestedTime + request.SchedulingInfo.MaxDeviationAfter > DateTime.Now)
{
_unscheduledRequests.Add(request);
}
else
{
AsLockable(request).Unlock(_instanceLock);
request.SchedulingInfo.SchedulingStatus = SchedulingStatus.CouldNotBeScheduled;
AsLockable(request).Lock(_instanceLock);
}
}
// Get Services for next time line
foreach (ServiceInstance request in GetServicesForTimeLine(reschedule))
{
_unscheduledRequests.Add(request);
}
// Copy unscheduled requests to an ordered list
var servicesForNextTimeLine = new List <ServiceInstance>(_unscheduledRequests
.OrderBy(schedulingdata => schedulingdata.SchedulingInfo.RequestedTime));
// ------------------------------------
#endregion
#region Find Match services
// ------------------------------------
//Same services or same services with same profile
foreach (ServiceInstance serviceInstance in servicesForNextTimeLine)
{
//Get all services with same configurationID
var requestsWithSameConfiguration = _scheduledRequests.GetWithSameConfiguration(serviceInstance);
//Get all services with same profileID
var requestsWithSameProfile = _scheduledRequests.GetWithSameProfile(serviceInstance);
//Find the first available time this service with specific service and profile
TimeSpan avgExecutionTime = GetAverageExecutionTime(serviceInstance.Configuration.ServiceName, Convert.ToInt32(serviceInstance.Configuration.Profile.Parameters["AccountID"]), _percentile);
DateTime baseStartTime = (serviceInstance.SchedulingInfo.RequestedTime < DateTime.Now) ? DateTime.Now : serviceInstance.SchedulingInfo.RequestedTime;
DateTime baseEndTime = baseStartTime.Add(avgExecutionTime);
DateTime calculatedStartTime = baseStartTime;
DateTime calculatedEndTime = baseEndTime;
bool found = false;
while (!found)
{
IOrderedEnumerable <ServiceInstance> whereToLookNext = null;
int countedPerConfiguration = requestsWithSameConfiguration.Count(s => (calculatedStartTime >= s.SchedulingInfo.ExpectedStartTime && calculatedStartTime <= s.SchedulingInfo.ExpectedEndTime) || (calculatedEndTime >= s.SchedulingInfo.ExpectedStartTime && calculatedEndTime <= s.SchedulingInfo.ExpectedEndTime));
if (countedPerConfiguration < serviceInstance.Configuration.Limits.MaxConcurrentGlobal)
{
int countedPerProfile = requestsWithSameProfile.Count(s => (calculatedStartTime >= s.SchedulingInfo.ExpectedStartTime && calculatedStartTime <= s.SchedulingInfo.ExpectedEndTime) || (calculatedEndTime >= s.SchedulingInfo.ExpectedStartTime && calculatedEndTime <= s.SchedulingInfo.ExpectedEndTime));
if (countedPerProfile < serviceInstance.Configuration.Limits.MaxConcurrentPerProfile)
{
AsLockable(serviceInstance).Unlock(_instanceLock);
serviceInstance.SchedulingInfo.ExpectedStartTime = calculatedStartTime;
serviceInstance.SchedulingInfo.ExpectedEndTime = calculatedEndTime;
serviceInstance.SchedulingInfo.SchedulingStatus = Services.SchedulingStatus.Scheduled;
AsLockable(serviceInstance).Lock(_instanceLock);
found = true;
}
else
{
whereToLookNext = requestsWithSameProfile;
}
}
else
{
whereToLookNext = requestsWithSameConfiguration;
}
if (!found)
{
if (whereToLookNext == null)
{
throw new Exception("This should not have happened.");
}
calculatedStartTime = whereToLookNext.Where(s => s.SchedulingInfo.ExpectedEndTime >= calculatedStartTime).Min(s => s.SchedulingInfo.ExpectedEndTime);
if (calculatedStartTime < DateTime.Now)
{
calculatedStartTime = DateTime.Now;
}
//Get end time
calculatedEndTime = calculatedStartTime.Add(avgExecutionTime);
////remove unfree time from servicePerConfiguration and servicePerProfile
if (calculatedStartTime <= _timeLineTo)
{
requestsWithSameConfiguration = from s in requestsWithSameConfiguration
where s.SchedulingInfo.ExpectedEndTime > calculatedStartTime
orderby s.SchedulingInfo.ExpectedStartTime
select s;
requestsWithSameProfile = from s in requestsWithSameProfile
where s.SchedulingInfo.ExpectedEndTime > calculatedStartTime
orderby s.SchedulingInfo.ExpectedStartTime
select s;
}
}
}
if (serviceInstance.SchedulingInfo.ExpectedDeviation <= serviceInstance.SchedulingInfo.MaxDeviationAfter || serviceInstance.SchedulingInfo.MaxDeviationAfter == TimeSpan.Zero)
{
AsLockable(serviceInstance).Unlock(_instanceLock);
serviceInstance.SchedulingInfo.SchedulingStatus = SchedulingStatus.Scheduled;
serviceInstance.StateChanged += new EventHandler(Instance_StateChanged);
AsLockable(serviceInstance).Lock(_instanceLock);
// Legacy stuff
//TODO: MAXEXECUTIONTIME
TimeSpan maxExecutionTime = TimeSpan.FromMilliseconds(avgExecutionTime.TotalMilliseconds * double.Parse(AppSettings.Get(this, "MaxExecutionTimeProduct")));
serviceInstance.Configuration.Limits.MaxExecutionTime = maxExecutionTime;
_scheduledRequests.Add(serviceInstance);
_unscheduledRequests.Remove(serviceInstance);
}
}
#endregion
}
SchedulingInformationEventArgs args = new SchedulingInformationEventArgs();
args.ScheduleInformation = new List <ServiceInstance>();
foreach (var scheduleService in _scheduledRequests)
{
args.ScheduleInformation.Add(scheduleService);
}
OnNewScheduleCreated(args);
NotifyServicesToRun();
}
}