public void EnableComponent(Guid accountId, Guid componentId)
{
var cache = new AccountCache(accountId);
IComponentCacheReadObject componentCacheRead = null;
using (var component = cache.Components.Write(componentId))
{
componentCacheRead = component;
component.Enable = true;
component.BeginSave();
}
UpdateParentEnableFlags(componentCacheRead, true);
RecalculateComponentStatuses(componentCacheRead);
}
public void DisableComponent(Guid accountId, Guid componentId, DateTime?toDate, string comment)
{
if (comment != null && comment.Length > 1000)
{
throw new ResponseCodeException(
Zidium.Api.ResponseCode.ParameterError,
"Максимальная длина комментария 1000 символов, а указано " + comment.Length);
}
if (toDate.HasValue && toDate < DateTime.Now)
{
throw new ResponseCodeException(
Zidium.Api.ResponseCode.ParameterError,
"Дата, до которой выключается компонент, должна быть больше текущего времени");
}
var cache = new AccountCache(accountId);
// обновим компонент
IComponentCacheReadObject componentCacheRead = null;
using (var component = cache.Components.Write(componentId))
{
// настройки выключения
component.Enable = false;
component.DisableComment = comment;
component.DisableToDate = toDate;
componentCacheRead = component;
component.BeginSave();
}
UpdateParentEnableFlags(componentCacheRead, true);
RecalculateComponentStatuses(componentCacheRead);
// обновим родительский компонент
if (componentCacheRead.ParentId != null)
{
var parent = cache.Components.Read(componentCacheRead.ParentId.Value);
RecalculateComponentStatuses(parent);
}
}
protected IComponentCacheReadObject RecalculateComponentStatuses(IComponentCacheReadObject component)
{
var accountId = component.AccountId;
var cache = new AccountCache(accountId);
IComponentCacheReadObject result = component;
// обновим ParentEnable
if (component.ParentId.HasValue)
{
var parent = cache.Components.Read(component.ParentId.Value);
if (parent.CanProcess != component.ParentEnable)
{
using (var componentWrite = cache.Components.Write(component))
{
componentWrite.ParentEnable = parent.CanProcess;
componentWrite.BeginSave();
component = componentWrite;
}
UpdateParentEnableFlags(component, true);
}
}
// если время выключения истекло, то включим компонент
if (component.Enable == false &&
component.DisableToDate.HasValue &&
component.DisableToDate < DateTime.Now)
{
using (var componentWrite = cache.Components.Write(component))
{
componentWrite.Enable = true;
componentWrite.BeginSave();
component = componentWrite;
result = component;
}
UpdateParentEnableFlags(component, true);
}
var statusService = Context.BulbService;
var allStatusesIds = component.GetAllStatusesIds();
var allStatuses = allStatusesIds.Select(cache.StatusDatas.Read).ToList();
// если надо выключить
if (component.CanProcess == false && allStatuses.Any(x => x.Status != Api.MonitoringStatus.Disabled))
{
// выключим все колбаски
// выжно выключить их в этом порядке, чтобы не создать лишних событий колбасок-родителей
var disableSignal = BulbSignal.CreateDisable(accountId, DateTime.Now);
statusService.SetSignal(component.ExternalStatusId, disableSignal);
statusService.SetSignal(component.ChildComponentsStatusId, disableSignal);
statusService.SetSignal(component.InternalStatusId, disableSignal);
statusService.SetSignal(component.EventsStatusId, disableSignal);
statusService.SetSignal(component.UnitTestsStatusId, disableSignal);
statusService.SetSignal(component.MetricsStatusId, disableSignal);
}
// обновим тесты
var allUnitTestsStatusDataIds = new List <Guid>();
foreach (var unitTestRef in component.UnitTests.GetAll())
{
using (var unitTest = cache.UnitTests.Write(unitTestRef.Id))
{
if (unitTest.IsDeleted)
{
continue;
}
allUnitTestsStatusDataIds.Add(unitTest.StatusDataId);
if (unitTest.ParentEnable != component.CanProcess)
{
unitTest.ParentEnable = component.CanProcess;
unitTest.BeginSave();
}
}
Context.UnitTestService.GetUnitTestResult(component.AccountId, unitTestRef.Id);
}
// обновим метрики
var allMetricsStatusDataIds = new List <Guid>();
Guid metricTypeId;
foreach (var metricRef in component.Metrics.GetAll())
{
using (var metric = cache.Metrics.Write(metricRef.Id))
{
if (metric.IsDeleted)
{
continue;
}
metricTypeId = metric.MetricTypeId;
allMetricsStatusDataIds.Add(metric.StatusDataId);
if (metric.ParentEnable != component.CanProcess)
{
metric.ParentEnable = component.CanProcess;
metric.BeginSave();
}
}
Context.MetricService.GetActualMetric(component.AccountId, component.Id, metricTypeId);
}
// проверим, нужно ли обновить детей
var childComponentsStatusDataIds = new List <Guid>();
foreach (var childRef in component.Childs.GetAll())
{
using (var child = cache.Components.Write(childRef.Id))
{
if (child.IsDeleted)
{
continue;
}
childComponentsStatusDataIds.Add(child.ExternalStatusId);
if (child.ParentEnable != component.CanProcess)
{
child.ParentEnable = component.CanProcess;
child.BeginSave();
}
}
GetComponentExternalState(component.AccountId, childRef.Id);
}
if (component.CanProcess)
{
// обновим колбасу тестов явно (вдруг нет ни одного теста)
statusService.CalculateByChilds(accountId, component.UnitTestsStatusId, allUnitTestsStatusDataIds);
// обновим колбасу метрик явно (вдруг нет ни одной метрики)
statusService.CalculateByChilds(accountId, component.MetricsStatusId, allMetricsStatusDataIds);
// обновим колбасу событий
CalculateComponentEventsStatus(accountId, component.EventsStatusId);
// обновим внутренний статус
var childsForInternal = new List <Guid>()
{
component.EventsStatusId,
component.UnitTestsStatusId,
component.MetricsStatusId
};
statusService.CalculateByChilds(accountId, component.InternalStatusId, childsForInternal);
// обновим колбасу дочерних
statusService.CalculateByChilds(accountId, component.ChildComponentsStatusId, childComponentsStatusDataIds);
// обновим внешний статус
var childsForExternal = new List <Guid>()
{
component.InternalStatusId,
component.ChildComponentsStatusId
};
statusService.CalculateByChilds(accountId, component.ExternalStatusId, childsForExternal);
}
return(result);
}
protected void UpdateParentEnableFlags(IComponentCacheReadObject component, bool recursive)
{
if (component == null)
{
throw new ArgumentNullException("component");
}
var cache = new AccountCache(component.AccountId);
var canProcess = component.CanProcess;
// обновим проверки
foreach (var unitTestRef in component.UnitTests.GetAll())
{
using (var unitTest = cache.UnitTests.Write(unitTestRef.Id))
{
if (unitTest.IsDeleted)
{
continue;
}
if (unitTest.ParentEnable != canProcess)
{
unitTest.ParentEnable = canProcess;
unitTest.BeginSave();
}
}
}
// обновим метрики
foreach (var metricRef in component.Metrics.GetAll())
{
using (var metric = cache.Metrics.Write(metricRef.Id))
{
if (metric.IsDeleted)
{
continue;
}
if (metric.ParentEnable != canProcess)
{
metric.ParentEnable = canProcess;
metric.BeginSave();
}
}
}
// обновим детей
foreach (var childRef in component.Childs.GetAll())
{
IComponentCacheReadObject childRead = null;
using (var child = cache.Components.Write(childRef.Id))
{
if (child.IsDeleted)
{
continue;
}
if (child.ParentEnable != canProcess)
{
childRead = child;
child.ParentEnable = canProcess;
child.BeginSave();
}
}
// если childRead is null, значит у ребенка уже актуальный флаг, его не надо апдейтить
if (recursive && childRead != null)
{
UpdateParentEnableFlags(childRead, recursive);
}
}
}
public void DeleteComponent(Guid accountId, Guid componentId)
{
var cache = new AccountCache(accountId);
IComponentCacheReadObject component = null;
ComponentCacheWriteObject componentWrite = null;
// Удаление компонента
using (componentWrite = cache.Components.Write(componentId))
{
if (componentWrite.IsDeleted)
{
return;
}
if (componentWrite.IsRoot)
{
throw new UserFriendlyException("Нельзя удалить root компонент");
}
componentWrite.IsDeleted = true;
componentWrite.BeginSave();
}
componentWrite.WaitSaveChanges(TimeSpan.FromSeconds(30));
component = componentWrite;
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
checker.RefreshComponentsCount();
// удаляем колбаски
foreach (var statusDataId in component.GetAllStatusesIds())
{
using (var statusData = cache.StatusDatas.Write(statusDataId))
{
statusData.IsDeleted = true;
statusData.BeginSave();
}
}
// Удаление метрик
foreach (var meticRef in component.Metrics.GetAll())
{
using (var metric = cache.Metrics.Write(meticRef.Id))
{
metric.IsDeleted = true;
metric.BeginSave();
// удаление колбаски метрики
using (var metricStatusData = cache.StatusDatas.Write(metric.StatusDataId))
{
metricStatusData.IsDeleted = true;
metricStatusData.BeginSave();
}
}
}
// Удаление проверок
foreach (var unitTestRef in component.UnitTests.GetAll())
{
using (var unitTest = cache.UnitTests.Write(unitTestRef.Id))
{
unitTest.IsDeleted = true;
unitTest.BeginSave();
// удаление колбаски проверки
using (var metricStatusData = cache.StatusDatas.Write(unitTest.StatusDataId))
{
metricStatusData.IsDeleted = true;
metricStatusData.BeginSave();
}
}
}
// Удаление вложенных компонентов
foreach (var child in component.Childs.GetAll())
{
DeleteComponent(accountId, child.Id);
}
// Если есть родитель, обновим его статус
if (component.ParentId.HasValue)
{
CalculateAllStatuses(accountId, component.ParentId.Value);
}
}
