Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
08/13/15 15:22:51 (9 years ago)
Author:
ascheibe
Message:

#2388

  • prevent disposing of hive data context
  • more cleanups
Location:
branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/HiveJanitor.cs

    r12789 r12858  
    5555
    5656    public void RunCleanup() {
     57      var pm = PersistenceManager;
    5758      while (!stop) {
    5859        try {
    5960          LogFactory.GetLogger(typeof(HiveJanitor).Namespace).Log("HiveJanitor: starting cleanup.");
    6061          bool cleanup = false;
    61           using (var pm = PersistenceManager) {
    62             var lifecycleDao = pm.LifecycleDao;
    63             pm.UseTransaction(() => {
    64               var lifecycle = lifecycleDao.GetLastLifecycle();
    65               if (lifecycle == null
    66                   || DateTime.Now - lifecycle.LastCleanup > HeuristicLab.Services.Hive.Properties.Settings.Default.CleanupInterval) {
    67                 lifecycleDao.UpdateLifecycle();
    68                 cleanup = true;
    69               }
    70               pm.SubmitChanges();
    71             }, true);
    72           }
     62
     63          var lifecycleDao = pm.LifecycleDao;
     64          pm.UseTransaction(() => {
     65            var lifecycle = lifecycleDao.GetLastLifecycle();
     66            if (lifecycle == null
     67                || DateTime.Now - lifecycle.LastCleanup > HeuristicLab.Services.Hive.Properties.Settings.Default.CleanupInterval) {
     68              lifecycleDao.UpdateLifecycle();
     69              cleanup = true;
     70            }
     71            pm.SubmitChanges();
     72          }, true);
     73
    7374          if (cleanup) {
    7475            EventManager.Cleanup();

  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs

    r12691 r12858  
    5252    public void AuthorizeForTask(Guid taskId, DT.Permission requiredPermission) {
    5353      if (ServiceLocator.Instance.RoleVerifier.IsInRole(HiveRoles.Slave)) return; // slave-users can access all tasks
    54       using (var pm = PersistenceManager) {
    55         var taskDao = pm.TaskDao;
    56         pm.UseTransaction(() => {
    57           var task = taskDao.GetById(taskId);
    58           if (task == null) throw new SecurityException(NOT_AUTHORIZED);
    59           AuthorizeJob(pm, task.JobId, requiredPermission);
    60         });
    61       }
     54      var pm = PersistenceManager;
     55      var taskDao = pm.TaskDao;
     56      pm.UseTransaction(() => {
     57        var task = taskDao.GetById(taskId);
     58        if (task == null) throw new SecurityException(NOT_AUTHORIZED);
     59        AuthorizeJob(pm, task.JobId, requiredPermission);
     60      });
    6261    }
    6362
    6463    public void AuthorizeForJob(Guid jobId, DT.Permission requiredPermission) {
    65       using (var pm = PersistenceManager) {
    66         pm.UseTransaction(() => {
    67           AuthorizeJob(pm, jobId, requiredPermission);
    68         });
    69       }
     64      var pm = PersistenceManager;
     65      pm.UseTransaction(() => {
     66        AuthorizeJob(pm, jobId, requiredPermission);
     67      });
    7068    }
    7169
    7270    public void AuthorizeForResourceAdministration(Guid resourceId) {
    73       using (var pm = PersistenceManager) {
    74         var resourceDao = pm.ResourceDao;
    75         pm.UseTransaction(() => {
    76           var resource = resourceDao.GetById(resourceId);
    77           if (resource == null) throw new SecurityException(NOT_AUTHORIZED);
    78           if (resource.OwnerUserId != UserManager.CurrentUserId
    79               && !RoleVerifier.IsInRole(HiveRoles.Administrator)) {
    80             throw new SecurityException(NOT_AUTHORIZED);
    81           }
    82         });
    83       }
     71      var pm = PersistenceManager;
     72      var resourceDao = pm.ResourceDao;
     73      pm.UseTransaction(() => {
     74        var resource = resourceDao.GetById(resourceId);
     75        if (resource == null) throw new SecurityException(NOT_AUTHORIZED);
     76        if (resource.OwnerUserId != UserManager.CurrentUserId
     77            && !RoleVerifier.IsInRole(HiveRoles.Administrator)) {
     78          throw new SecurityException(NOT_AUTHORIZED);
     79        }
     80      });
    8481    }
    8582

  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/Manager/NewEventManager.cs

    r12853 r12858  
    3131      get { return ServiceLocator.Instance.PersistenceManager; }
    3232    }
    33     private IAuthorizationManager AuthorizationManager {
    34       get { return ServiceLocator.Instance.AuthorizationManager; }
    35     }
    36     private ILogger Log {
    37       get { return LogFactory.GetLogger(this.GetType().Namespace); }
    38     }
    3933
    4034    public void Cleanup() {
    41       using (var pm = PersistenceManager) {
    42         // same transactions as the old EventManager
    43         pm.UseTransaction(() => {
    44           SetTimeoutSlavesOffline(pm);
    45           SetTimeoutTasksWaiting(pm);
    46           DeleteObsoleteSlaves(pm);
    47           pm.SubmitChanges();
    48         });
     35      var pm = PersistenceManager;
     36      // same transactions as the old EventManager
     37      pm.UseTransaction(() => {
     38        SetTimeoutSlavesOffline(pm);
     39        SetTimeoutTasksWaiting(pm);
     40        DeleteObsoleteSlaves(pm);
     41        pm.SubmitChanges();
     42      });
    4943
    50         pm.UseTransaction(() => {
    51           FinishParentTasks(pm);
    52           pm.SubmitChanges();
    53         });
    54       }
     44      pm.UseTransaction(() => {
     45        FinishParentTasks(pm);
     46        pm.SubmitChanges();
     47      });
    5548    }
    5649

  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/Manager/NewHeartbeatManager.cs

    r12773 r12858  
    4747    public List<MessageContainer> ProcessHeartbeat(Heartbeat heartbeat) {
    4848      List<MessageContainer> actions = new List<MessageContainer>();
    49       using (var pm = PersistenceManager) {
    50         var slaveDao = pm.SlaveDao;
    51         var taskDao = pm.TaskDao;
    52         var slave = pm.UseTransaction(() => slaveDao.GetById(heartbeat.SlaveId));
    53         if (slave == null) {
    54           actions.Add(new MessageContainer(MessageContainer.MessageType.SayHello));
    55         } else {
    56           if (heartbeat.HbInterval != slave.HbInterval) {
    57             actions.Add(new MessageContainer(MessageContainer.MessageType.NewHBInterval));
    58           }
    59           if (slaveDao.SlaveHasToShutdownComputer(slave.ResourceId)) {
    60             actions.Add(new MessageContainer(MessageContainer.MessageType.ShutdownComputer));
    61           }
    62           // update slave data 
    63           slave.FreeCores = heartbeat.FreeCores;
    64           slave.FreeMemory = heartbeat.FreeMemory;
    65           slave.CpuUtilization = heartbeat.CpuUtilization;
    66           slave.SlaveState = (heartbeat.JobProgress != null && heartbeat.JobProgress.Count > 0)
    67             ? DA.SlaveState.Calculating
    68             : DA.SlaveState.Idle;
    69           slave.LastHeartbeat = DateTime.Now;
    70           pm.UseTransaction(() => {
    71             slave.IsAllowedToCalculate = slaveDao.SlaveIsAllowedToCalculate(slave.ResourceId);
    72             pm.SubmitChanges();
    73           });
    74 
    75           // update task data
    76           actions.AddRange(UpdateTasks(pm, heartbeat, slave.IsAllowedToCalculate));
    77 
    78           // assign new task
    79           if (heartbeat.AssignJob && slave.IsAllowedToCalculate && heartbeat.FreeCores > 0) {
    80             bool mutexAquired = false;
    81             var mutex = new Mutex(false, MutexName);
    82             try {
    83               mutexAquired = mutex.WaitOne(Properties.Settings.Default.SchedulingPatience);
    84               if (mutexAquired) {
    85                 var waitingTasks = pm.UseTransaction(() => taskDao.GetWaitingTasks(slave)
    86                     .Select(x => new TaskInfoForScheduler {
    87                       TaskId = x.TaskId,
    88                       JobId = x.JobId,
    89                       Priority = x.Priority
    90                     })
    91                     .ToList()
    92                 );
    93                 var availableTasks = TaskScheduler.Schedule(waitingTasks);
    94                 if (availableTasks.Any()) {
    95                   var task = availableTasks.First();
    96                   AssignTask(pm, slave, task.TaskId);
    97                   actions.Add(new MessageContainer(MessageContainer.MessageType.CalculateTask, task.TaskId));
    98                 }
    99               } else {
    100                 LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling could not be aquired.");
     49      var pm = PersistenceManager;
     50      var slaveDao = pm.SlaveDao;
     51      var taskDao = pm.TaskDao;
     52      var slave = pm.UseTransaction(() => slaveDao.GetById(heartbeat.SlaveId));
     53      if (slave == null) {
     54        actions.Add(new MessageContainer(MessageContainer.MessageType.SayHello));
     55      } else {
     56        if (heartbeat.HbInterval != slave.HbInterval) {
     57          actions.Add(new MessageContainer(MessageContainer.MessageType.NewHBInterval));
     58        }
     59        if (slaveDao.SlaveHasToShutdownComputer(slave.ResourceId)) {
     60          actions.Add(new MessageContainer(MessageContainer.MessageType.ShutdownComputer));
     61        }
     62        // update slave data 
     63        slave.FreeCores = heartbeat.FreeCores;
     64        slave.FreeMemory = heartbeat.FreeMemory;
     65        slave.CpuUtilization = heartbeat.CpuUtilization;
     66        slave.SlaveState = (heartbeat.JobProgress != null && heartbeat.JobProgress.Count > 0)
     67          ? DA.SlaveState.Calculating
     68          : DA.SlaveState.Idle;
     69        slave.LastHeartbeat = DateTime.Now;
     70        pm.UseTransaction(() => {
     71          slave.IsAllowedToCalculate = slaveDao.SlaveIsAllowedToCalculate(slave.ResourceId);
     72          pm.SubmitChanges();
     73        });
     74
     75        // update task data
     76        actions.AddRange(UpdateTasks(pm, heartbeat, slave.IsAllowedToCalculate));
     77
     78        // assign new task
     79        if (heartbeat.AssignJob && slave.IsAllowedToCalculate && heartbeat.FreeCores > 0) {
     80          bool mutexAquired = false;
     81          var mutex = new Mutex(false, MutexName);
     82          try {
     83            mutexAquired = mutex.WaitOne(Properties.Settings.Default.SchedulingPatience);
     84            if (mutexAquired) {
     85              var waitingTasks = pm.UseTransaction(() => taskDao.GetWaitingTasks(slave)
     86                  .Select(x => new TaskInfoForScheduler {
     87                    TaskId = x.TaskId,
     88                    JobId = x.JobId,
     89                    Priority = x.Priority
     90                  })
     91                  .ToList()
     92              );
     93              var availableTasks = TaskScheduler.Schedule(waitingTasks).ToArray();
     94              if (availableTasks.Any()) {
     95                var task = availableTasks.First();
     96                AssignTask(pm, slave, task.TaskId);
     97                actions.Add(new MessageContainer(MessageContainer.MessageType.CalculateTask, task.TaskId));
    10198              }
     99            } else {
     100              LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling could not be aquired.");
    102101            }
    103             catch (AbandonedMutexException) {
    104               LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling has been abandoned.");
    105             }
    106             catch (Exception ex) {
    107               LogFactory.GetLogger(this.GetType().Namespace).Log(string.Format("HeartbeatManager threw an exception in ProcessHeartbeat: {0}", ex));
    108             }
    109             finally {
    110               if (mutexAquired) mutex.ReleaseMutex();
    111             }
     102          }
     103          catch (AbandonedMutexException) {
     104            LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling has been abandoned.");
     105          }
     106          catch (Exception ex) {
     107            LogFactory.GetLogger(this.GetType().Namespace).Log(string.Format("HeartbeatManager threw an exception in ProcessHeartbeat: {0}", ex));
     108          }
     109          finally {
     110            if (mutexAquired) mutex.ReleaseMutex();
    112111          }
    113112        }

  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/Scheduler/NewRoundRobinTaskScheduler.cs

    r12691 r12858  
    3535      if (!tasks.Any()) return Enumerable.Empty<TaskInfoForScheduler>();
    3636
    37       using (var pm = PersistenceManager) {
    38         var userPriorityDao = pm.UserPriorityDao;
    39         var jobDao = pm.JobDao;
     37      var pm = PersistenceManager;
     38      var userPriorityDao = pm.UserPriorityDao;
     39      var jobDao = pm.JobDao;
    4040
    41         var userPriorities = pm.UseTransaction(() => userPriorityDao.GetAll()
    42           .OrderBy(x => x.DateEnqueued)
    43           .ToArray()
    44         );
     41      var userPriorities = pm.UseTransaction(() => userPriorityDao.GetAll()
     42        .OrderBy(x => x.DateEnqueued)
     43        .ToArray()
     44      );
    4545
    46         var userIds = userPriorities.Select(x => x.UserId).ToList();
    47         var jobs = pm.UseTransaction(() => {
    48           return jobDao.GetAll()
    49             .Where(x => userIds.Contains(x.OwnerUserId))
    50             .Select(x => new {
    51               Id = x.JobId,
    52               DateCreated = x.DateCreated,
    53               OwnerUserId = x.OwnerUserId
    54             })
    55             .ToList();
    56         });
     46      var userIds = userPriorities.Select(x => x.UserId).ToList();
     47      var jobs = pm.UseTransaction(() => {
     48        return jobDao.GetAll()
     49          .Where(x => userIds.Contains(x.OwnerUserId))
     50          .Select(x => new {
     51            Id = x.JobId,
     52            DateCreated = x.DateCreated,
     53            OwnerUserId = x.OwnerUserId
     54          })
     55          .ToList();
     56      });
    5757
    58         var taskJobRelations = tasks.Join(jobs,
    59           task => task.JobId,
    60           job => job.Id,
    61           (task, job) => new { Task = task, JobInfo = job })
    62           .OrderByDescending(x => x.Task.Priority)
    63           .ToList();
     58      var taskJobRelations = tasks.Join(jobs,
     59        task => task.JobId,
     60        job => job.Id,
     61        (task, job) => new { Task = task, JobInfo = job })
     62        .OrderByDescending(x => x.Task.Priority)
     63        .ToList();
    6464
    65         var scheduledTasks = new List<TaskInfoForScheduler>();
    66         int priorityIndex = 0;
     65      var scheduledTasks = new List<TaskInfoForScheduler>();
     66      int priorityIndex = 0;
    6767
    68         if (count == 0 || count > taskJobRelations.Count) count = taskJobRelations.Count;
     68      if (count == 0 || count > taskJobRelations.Count) count = taskJobRelations.Count;
    6969
    70         for (int i = 0; i < count; i++) {
    71           var defaultEntry = taskJobRelations.First(); // search first task which is not included yet
    72           var priorityEntries = taskJobRelations.Where(x => x.JobInfo.OwnerUserId == userPriorities[priorityIndex].UserId).ToArray(); // search for tasks with desired user priority
    73           while (!priorityEntries.Any() && priorityIndex < userPriorities.Length - 1) {
     70      for (int i = 0; i < count; i++) {
     71        var defaultEntry = taskJobRelations.First(); // search first task which is not included yet
     72        var priorityEntries = taskJobRelations.Where(x => x.JobInfo.OwnerUserId == userPriorities[priorityIndex].UserId).ToArray(); // search for tasks with desired user priority
     73        while (!priorityEntries.Any() && priorityIndex < userPriorities.Length - 1) {
     74          priorityIndex++;
     75          priorityEntries = taskJobRelations.Where(x => x.JobInfo.OwnerUserId == userPriorities[priorityIndex].UserId).ToArray();
     76        }
     77        if (priorityEntries.Any()) { // tasks with desired user priority found
     78          var priorityEntry = priorityEntries.OrderByDescending(x => x.Task.Priority).ThenBy(x => x.JobInfo.DateCreated).First();
     79          if (defaultEntry.Task.Priority <= priorityEntry.Task.Priority) {
     80            taskJobRelations.Remove(priorityEntry);
     81            scheduledTasks.Add(priorityEntry.Task);
     82            UpdateUserPriority(pm, userPriorities[priorityIndex]);
    7483            priorityIndex++;
    75             priorityEntries = taskJobRelations.Where(x => x.JobInfo.OwnerUserId == userPriorities[priorityIndex].UserId).ToArray();
    76           }
    77           if (priorityEntries.Any()) { // tasks with desired user priority found
    78             var priorityEntry = priorityEntries.OrderByDescending(x => x.Task.Priority).ThenBy(x => x.JobInfo.DateCreated).First();
    79             if (defaultEntry.Task.Priority <= priorityEntry.Task.Priority) {
    80               taskJobRelations.Remove(priorityEntry);
    81               scheduledTasks.Add(priorityEntry.Task);
    82               UpdateUserPriority(pm, userPriorities[priorityIndex]);
    83               priorityIndex++;
    84             } else { // there are other tasks with higher priorities
    85               taskJobRelations.Remove(defaultEntry);
    86               scheduledTasks.Add(defaultEntry.Task);
    87             }
    88           } else {
     84          } else { // there are other tasks with higher priorities
    8985            taskJobRelations.Remove(defaultEntry);
    9086            scheduledTasks.Add(defaultEntry.Task);
    9187          }
    92           if (priorityIndex >= (userPriorities.Length - 1)) priorityIndex = 0;
     88        } else {
     89          taskJobRelations.Remove(defaultEntry);
     90          scheduledTasks.Add(defaultEntry.Task);
    9391        }
    94         return scheduledTasks;
     92        if (priorityIndex >= (userPriorities.Length - 1)) priorityIndex = 0;
    9593      }
     94      return scheduledTasks;
     95
    9696    }
    9797
Note: See TracChangeset for help on using the changeset viewer.