public string GetUsernameByUserId(Guid userId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var user = UserManager.GetUserById(userId);
return(user != null ? user.UserName : null);
}
public IEnumerable <DT.SlaveGroup> GetSlaveGroups()
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
bool isAdministrator = RoleVerifier.IsInRole(HiveRoles.Administrator);
var pm = PersistenceManager;
using (new PerformanceLogger("GetSlaveGroups")) {
var slaveGroupDao = pm.SlaveGroupDao;
var resourcePermissionDao = pm.ResourcePermissionDao;
var currentUserId = UserManager.CurrentUserId;
return(pm.UseTransaction(() => {
var resourcePermissions = resourcePermissionDao.GetAll();
return slaveGroupDao.GetAll().ToList()
.Where(x => isAdministrator ||
x.OwnerUserId == null ||
x.OwnerUserId == currentUserId ||
UserManager.VerifyUser(currentUserId, resourcePermissions
.Where(y => y.ResourceId == x.ResourceId)
.Select(z => z.GrantedUserId)
.ToList())
)
.Select(x => x.ToDto())
.ToList();
}));
}
}
public void TriggerEventManager(bool force)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator);
// use a serializable transaction here to ensure not two threads execute this simultaniously (mutex-lock would not work since IIS may use multiple AppDomains)
bool cleanup;
var pm = PersistenceManager;
using (new PerformanceLogger("TriggerEventManager")) {
cleanup = false;
var lifecycleDao = pm.LifecycleDao;
pm.UseTransaction(() => {
var lastLifecycle = lifecycleDao.GetLastLifecycle();
DateTime lastCleanup = lastLifecycle != null ? lastLifecycle.LastCleanup : DateTime.MinValue;
if (force || DateTime.Now - lastCleanup > HeuristicLab.Services.Hive.Properties.Settings.Default.CleanupInterval)
{
lifecycleDao.UpdateLifecycle();
cleanup = true;
pm.SubmitChanges();
}
}, true);
}
if (cleanup)
{
EventManager.Cleanup();
}
}
public Guid AddPlugin(DT.Plugin plugin, List <DT.PluginData> pluginData)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("AddPlugin")) {
var pluginDao = pm.PluginDao;
plugin.UserId = UserManager.CurrentUserId;
plugin.DateCreated = DateTime.Now;
return(pm.UseTransaction(() => {
var pluginEntity = pluginDao.GetByHash(plugin.Hash).SingleOrDefault();
if (pluginEntity != null)
{
throw new FaultException <PluginAlreadyExistsFault>(new PluginAlreadyExistsFault(pluginEntity.PluginId));
}
pluginEntity = plugin.ToEntity();
foreach (var data in pluginData)
{
data.PluginId = default(Guid); // real id will be assigned from linq2sql
pluginEntity.PluginData.Add(data.ToEntity());
}
pluginDao.Save(pluginEntity);
pm.SubmitChanges();
return pluginEntity.PluginId;
}));
}
}
public Guid AddTask(DT.Task task, DT.TaskData taskData, IEnumerable <Guid> resourceIds)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("AddTask")) {
var taskDao = pm.TaskDao;
var stateLogDao = pm.StateLogDao;
var newTask = task.ToEntity();
newTask.JobData = taskData.ToEntity();
newTask.JobData.LastUpdate = DateTime.Now;
newTask.AssignedResources.AddRange(resourceIds.Select(
x => new DA.AssignedResource {
ResourceId = x
}));
newTask.State = DA.TaskState.Waiting;
return(pm.UseTransaction(() => {
taskDao.Save(newTask);
pm.SubmitChanges();
stateLogDao.Save(new DA.StateLog {
State = DA.TaskState.Waiting,
DateTime = DateTime.Now,
TaskId = newTask.TaskId,
UserId = UserManager.CurrentUserId,
SlaveId = null,
Exception = null
});
pm.SubmitChanges();
return newTask.TaskId;
}, false, true));
}
}
public void Hello(DT.Slave slaveInfo)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Slave);
if (UserManager.CurrentUser.UserName != "hiveslave")
{
slaveInfo.OwnerUserId = UserManager.CurrentUserId;
}
var pm = PersistenceManager;
using (new PerformanceLogger("Hello")) {
var slaveDao = pm.SlaveDao;
pm.UseTransaction(() => {
var slave = slaveDao.GetById(slaveInfo.Id);
if (slave == null)
{
slaveDao.Save(slaveInfo.ToEntity());
}
else
{
bool oldIsAllowedToCalculate = slave.IsAllowedToCalculate;
Guid?oldParentResourceId = slave.ParentResourceId;
slaveInfo.CopyToEntity(slave);
slave.IsAllowedToCalculate = oldIsAllowedToCalculate;
slave.ParentResourceId = oldParentResourceId;
slave.LastHeartbeat = DateTime.Now;
slave.SlaveState = DA.SlaveState.Idle;
}
pm.SubmitChanges();
});
}
}
public void UpdateJob(DT.Job jobDto)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForJob(jobDto.Id, DT.Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("UpdateJob")) {
bool exists = true;
var jobDao = pm.JobDao;
pm.UseTransaction(() => {
var job = jobDao.GetById(jobDto.Id);
if (job == null)
{
exists = false;
job = new DA.Job();
}
jobDto.CopyToEntity(job);
if (!exists)
{
jobDao.Save(job);
}
pm.SubmitChanges();
});
}
}
public IEnumerable <DT.LightweightTask> GetLightweightJobTasks(Guid jobId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForJob(jobId, Permission.Read);
var pm = PersistenceManager;
using (new PerformanceLogger("GetLightweightJobTasks")) {
var taskDao = pm.TaskDao;
return(pm.UseTransaction(() => {
return taskDao.GetByJobId(jobId)
.ToList()
.Select(x => new DT.LightweightTask {
Id = x.TaskId,
ExecutionTime = TimeSpan.FromMilliseconds(x.ExecutionTimeMs),
ParentTaskId = x.ParentTaskId,
StateLog = x.StateLogs.OrderBy(y => y.DateTime)
.Select(z => z.ToDto())
.ToList(),
State = x.State.ToDto(),
Command = x.Command.ToDto(),
LastTaskDataUpdate = x.JobData.LastUpdate
})
.ToList();
}, false, true));
}
}
public Guid GetUserIdByUsername(string username)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var user = ServiceLocator.Instance.UserManager.GetUserByName(username);
return(user != null ? (Guid?)user.ProviderUserKey ?? Guid.Empty : Guid.Empty);
}
public void PauseTask(Guid taskId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("PauseTask")) {
var taskDao = pm.TaskDao;
pm.UseTransaction(() => {
var task = taskDao.GetById(taskId);
if (task.State == DA.TaskState.Calculating || task.State == DA.TaskState.Transferring)
{
task.Command = DA.Command.Pause;
}
else if (task.State != DA.TaskState.Paused &&
task.State != DA.TaskState.Aborted &&
task.State != DA.TaskState.Finished &&
task.State != DA.TaskState.Failed)
{
UpdateTaskState(pm, task, DT.TaskState.Paused, null, null, string.Empty);
}
pm.SubmitChanges();
});
}
}
public DT.Plugin GetPlugin(Guid pluginId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
var pm = PersistenceManager;
using (new PerformanceLogger("GetPlugin")) {
var pluginDao = pm.PluginDao;
return(pm.UseTransaction(() => pluginDao.GetById(pluginId).ToDto()));
}
}
public DT.Slave GetSlave(Guid slaveId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator);
var pm = PersistenceManager;
using (new PerformanceLogger("GetSlave")) {
var slaveDao = pm.SlaveDao;
return(pm.UseTransaction(() => slaveDao.GetById(slaveId).ToDto()));
}
}
public DT.TaskData GetTaskData(Guid taskId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
AuthorizationManager.AuthorizeForTask(taskId, Permission.Read);
var pm = PersistenceManager;
using (new PerformanceLogger("GetTaskData")) {
var taskDataDao = pm.TaskDataDao;
return(pm.UseTransaction(() => taskDataDao.GetById(taskId).ToDto()));
}
}
public void DeleteDowntime(Guid downtimeId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("DeleteDowntime")) {
var downtimeDao = pm.DowntimeDao;
pm.UseTransaction(() => {
downtimeDao.Delete(downtimeId);
pm.SubmitChanges();
});
}
}
public Guid GetResourceId(string resourceName)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("GetResourceId")) {
var resourceDao = pm.ResourceDao;
return(pm.UseTransaction(() => {
var resource = resourceDao.GetByName(resourceName);
return resource != null ? resource.ResourceId : Guid.Empty;
}));
}
}
public IEnumerable <DT.ResourcePermission> GetResourcePermissions(Guid resourceId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("GetResourcePermissions")) {
var resourcePermissionDao = pm.ResourcePermissionDao;
return(pm.UseTransaction(() => resourcePermissionDao.GetByResourceId(resourceId)
.Select(x => x.ToDto())
.ToList()
));
}
}
public void RemoveResourceFromGroup(Guid slaveGroupId, Guid resourceId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator);
var pm = PersistenceManager;
using (new PerformanceLogger("RemoveResourceFromGroup")) {
var resourceDao = pm.ResourceDao;
pm.UseTransaction(() => {
var resource = resourceDao.GetById(resourceId);
resource.ParentResourceId = null;
pm.SubmitChanges();
});
}
}
public void DeleteSlaveGroup(Guid slaveGroupId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForResourceAdministration(slaveGroupId);
var pm = PersistenceManager;
using (new PerformanceLogger("DeleteSlaveGroup")) {
var slaveGroupDao = pm.SlaveGroupDao;
pm.UseTransaction(() => {
slaveGroupDao.Delete(slaveGroupId);
pm.SubmitChanges();
});
}
}
public Guid AddSlave(DT.Slave slaveDto)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator);
var pm = PersistenceManager;
using (new PerformanceLogger("AddSlave")) {
var slaveDao = pm.SlaveDao;
return(pm.UseTransaction(() => {
var slave = slaveDao.Save(slaveDto.ToEntity());
pm.SubmitChanges();
return slave.ResourceId;
}));
}
}
public IEnumerable <DT.PluginData> GetPluginDatas(List <Guid> pluginIds)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
var pm = PersistenceManager;
using (new PerformanceLogger("GetPluginDatas")) {
var pluginDataDao = pm.PluginDataDao;
return(pm.UseTransaction(() => pluginDataDao.GetAll()
.Where(x => pluginIds.Contains(x.PluginId))
.Select(x => x.ToDto())
.ToList()
));
}
}
public void RevokeResourcePermissions(Guid resourceId, Guid[] grantedUserIds)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("RevokeResourcePermissions")) {
var resourcePermissionDao = pm.ResourcePermissionDao;
pm.UseTransaction(() => {
AuthorizeForResource(pm, resourceId);
resourcePermissionDao.DeleteByResourceAndGrantedUserId(resourceId, grantedUserIds);
pm.SubmitChanges();
});
}
}
public IEnumerable <JobPermission> GetJobPermissions(Guid jobId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForJob(jobId, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("GetJobPermissions")) {
var jobPermissionDao = pm.JobPermissionDao;
return(pm.UseTransaction(() => jobPermissionDao.GetByJobId(jobId)
.Select(x => x.ToDto())
.ToList()
));
}
}
public IEnumerable <DT.Job> GetJobs()
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
var pm = PersistenceManager;
using (new PerformanceLogger("GetJobs")) {
var jobDao = pm.JobDao;
var jobPermissionDao = pm.JobPermissionDao;
var taskDao = pm.TaskDao;
var currentUserId = UserManager.CurrentUserId;
return(pm.UseTransaction(() => {
var jobs = jobDao.GetAll()
.Where(x => x.OwnerUserId == currentUserId ||
x.JobPermissions.Count(y => y.Permission != DA.Permission.NotAllowed &&
y.GrantedUserId == currentUserId) > 0)
.Select(x => x.ToDto())
.ToList();
var statistics = taskDao.GetAll()
.GroupBy(x => x.JobId)
.Select(x => new {
x.Key,
TotalCount = x.Count(),
CalculatingCount = x.Count(y => y.State == DA.TaskState.Calculating),
FinishedCount = x.Count(y => CompletedStates.Contains(y.State))
})
.ToList();
foreach (var job in jobs)
{
var statistic = statistics.FirstOrDefault(x => x.Key == job.Id);
if (statistic != null)
{
job.JobCount = statistic.TotalCount;
job.CalculatingCount = statistic.CalculatingCount;
job.FinishedCount = statistic.FinishedCount;
}
job.OwnerUsername = UserManager.GetUserNameById(job.OwnerUserId);
if (currentUserId == job.OwnerUserId)
{
job.Permission = Permission.Full;
}
else
{
var jobPermission = jobPermissionDao.GetByJobAndUserId(job.Id, currentUserId);
job.Permission = jobPermission == null ? Permission.NotAllowed : jobPermission.Permission.ToDto();
}
}
return jobs;
}));
}
}
public Guid AddDowntime(DT.Downtime downtimeDto)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForResourceAdministration(downtimeDto.ResourceId);
var pm = PersistenceManager;
using (new PerformanceLogger("AddDowntime")) {
var downtimeDao = pm.DowntimeDao;
return(pm.UseTransaction(() => {
var downtime = downtimeDao.Save(downtimeDto.ToEntity());
pm.SubmitChanges();
return downtime.ResourceId;
}));
}
}
public void RevokePermission(Guid jobId, Guid grantedUserId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForJob(jobId, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("RevokePermission")) {
var jobPermissionDao = pm.JobPermissionDao;
var currentUserId = UserManager.CurrentUserId;
pm.UseTransaction(() => {
jobPermissionDao.SetJobPermission(jobId, currentUserId, grantedUserId, DA.Permission.NotAllowed);
pm.SubmitChanges();
});
}
}
public void DeleteJob(Guid jobId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
AuthorizationManager.AuthorizeForJob(jobId, DT.Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("DeleteJob")) {
var jobDao = pm.JobDao;
pm.UseTransaction(() => {
// child task will be deleted by db-trigger
jobDao.Delete(jobId);
pm.SubmitChanges();
});
}
}
public void UpdateTask(DT.Task taskDto)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
AuthorizationManager.AuthorizeForTask(taskDto.Id, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("UpdateTask")) {
var taskDao = pm.TaskDao;
pm.UseTransaction(() => {
var task = taskDao.GetById(taskDto.Id);
taskDto.CopyToEntity(task);
pm.SubmitChanges();
});
}
}
public DT.Task UpdateTaskState(Guid taskId, DT.TaskState taskState, Guid?slaveId, Guid?userId, string exception)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("UpdateTaskState")) {
var taskDao = pm.TaskDao;
return(pm.UseTransaction(() => {
var task = taskDao.GetById(taskId);
UpdateTaskState(pm, task, taskState, slaveId, userId, exception);
pm.SubmitChanges();
return task.ToDto();
}));
}
}
private DA.Resource AuthorizeForResource(IPersistenceManager pm, Guid resourceId)
{
var resourceDao = pm.ResourceDao;
var resource = resourceDao.GetById(resourceId);
if (resource == null)
{
throw new SecurityException("Not authorized");
}
if (resource.OwnerUserId != UserManager.CurrentUserId &&
!RoleVerifier.IsInRole(HiveRoles.Administrator))
{
throw new SecurityException("Not authorized");
}
return(resource);
}
public void RestartTask(Guid taskId)
{
RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
var pm = PersistenceManager;
using (new PerformanceLogger("RestartTask")) {
var taskDao = pm.TaskDao;
pm.UseTransaction(() => {
var task = taskDao.GetById(taskId);
task.Command = null;
UpdateTaskState(pm, task, DT.TaskState.Waiting, null, UserManager.CurrentUserId, string.Empty);
pm.SubmitChanges();
});
}
}
