protected override void OnExecute(CommandProcessor theProcessor, IUpdateContext updateContext) { var filesystemQueueBroker= updateContext.GetBroker<IFilesystemQueueEntityBroker>(); var criteria = new FilesystemQueueSelectCriteria(); criteria.StudyStorageKey.EqualTo(_storageLocationKey); IList<FilesystemQueue> filesystemQueueItems = filesystemQueueBroker.Find(criteria); var workQueueBroker = updateContext.GetBroker<IWorkQueueEntityBroker>(); var workQueueCriteria = new WorkQueueSelectCriteria(); workQueueCriteria.StudyStorageKey.EqualTo(_storageLocationKey); workQueueCriteria.WorkQueueTypeEnum.In(new[] { WorkQueueTypeEnum.PurgeStudy, WorkQueueTypeEnum.DeleteStudy, WorkQueueTypeEnum.CompressStudy, WorkQueueTypeEnum.MigrateStudy }); IList<WorkQueue> workQueueItems = workQueueBroker.Find(workQueueCriteria); foreach (FilesystemQueue queue in filesystemQueueItems) { bool delete = false; if (_applyTime.Equals(ServerRuleApplyTimeEnum.StudyArchived)) { if (queue.FilesystemQueueTypeEnum.Equals(FilesystemQueueTypeEnum.PurgeStudy)) delete = true; } else { delete = true; } if (delete) { if (!filesystemQueueBroker.Delete(queue.GetKey())) throw new ApplicationException("Unable to delete items in the filesystem queue"); } } if (!_applyTime.Equals(ServerRuleApplyTimeEnum.StudyArchived)) { // delete work queue foreach (Model.WorkQueue item in workQueueItems) { if (!item.Delete(updateContext)) throw new ApplicationException("Unable to delete items in the work queue"); } } }
protected override void OnExecute(CommandProcessor theProcessor, IUpdateContext updateContext) { // update FilesystemStudyStorage if (Context != null) { Platform.Log(LogLevel.Info, "Updating database..."); IFilesystemStudyStorageEntityBroker broker = updateContext.GetBroker<IFilesystemStudyStorageEntityBroker>(); FilesystemStudyStorageSelectCriteria searchCriteria = new FilesystemStudyStorageSelectCriteria(); searchCriteria.StudyStorageKey.EqualTo(Context.OriginalStudyLocation.GetKey()); searchCriteria.FilesystemKey.EqualTo(Context.OriginalStudyLocation.FilesystemKey); FilesystemStudyStorage filesystemStudyStorage = broker.FindOne(searchCriteria); Debug.Assert(filesystemStudyStorage != null); // Update Filesystem for the StudyStorage entry filesystemStudyStorage.FilesystemKey = Context.Destination.Filesystem.GetKey(); broker.Update(filesystemStudyStorage); // Update Filesystem for the remaining FilesystemQueue entries IFilesystemQueueEntityBroker fsQueueBroker = updateContext.GetBroker<IFilesystemQueueEntityBroker>(); FilesystemQueueSelectCriteria fsQueueSearchCriteria = new FilesystemQueueSelectCriteria(); fsQueueSearchCriteria.StudyStorageKey.EqualTo(Context.OriginalStudyLocation.GetKey()); fsQueueSearchCriteria.FilesystemKey.EqualTo(Context.OriginalStudyLocation.FilesystemKey); FilesystemQueueUpdateColumns fsQueueUpdateColumns = new FilesystemQueueUpdateColumns(); fsQueueUpdateColumns.FilesystemKey = Context.Destination.Filesystem.GetKey(); fsQueueBroker.Update(fsQueueSearchCriteria, fsQueueUpdateColumns); // Insert or update Filesystem Queue table. IInsertFilesystemQueue insertFilesystemQueueBroker = updateContext.GetBroker<IInsertFilesystemQueue>(); FilesystemQueueInsertParameters parms = new FilesystemQueueInsertParameters(); parms.FilesystemKey = Context.Destination.Filesystem.GetKey(); parms.FilesystemQueueTypeEnum = FilesystemQueueTypeEnum.TierMigrate; parms.ScheduledTime = Platform.Time; parms.StudyStorageKey = Context.OriginalStudyLocation.GetKey(); insertFilesystemQueueBroker.Execute(parms); Platform.Log(LogLevel.Info, "Database is updated."); } }
/// <summary> /// Get a list of candidates from the <see cref="FilesystemQueue"/>. /// </summary> /// <param name="item">The ServiceLock item.</param> /// <param name="scheduledTime">The scheduled time to query against</param> /// <param name="type">The type of FilesystemQueue entry.</param> /// <param name="statusCheck">If true, check for specific status value WorkQueue entries already existing, otherwise check for any WorkQueue entry.</param> /// <returns>The list of queue entries.</returns> protected IList<FilesystemQueue> GetFilesystemQueueCandidates(Model.ServiceLock item, DateTime scheduledTime, FilesystemQueueTypeEnum type, bool statusCheck) { using (ServerExecutionContext context = new ServerExecutionContext()) { IFilesystemQueueEntityBroker broker = context.ReadContext.GetBroker<IFilesystemQueueEntityBroker>(); FilesystemQueueSelectCriteria fsQueueCriteria = new FilesystemQueueSelectCriteria(); fsQueueCriteria.FilesystemKey.EqualTo(item.FilesystemKey); fsQueueCriteria.ScheduledTime.LessThanOrEqualTo(scheduledTime); fsQueueCriteria.FilesystemQueueTypeEnum.EqualTo(type); // Do the select based on the QueueStudyState (used to be based on a link to the WorkQueue table) StudyStorageSelectCriteria studyStorageSearchCriteria = new StudyStorageSelectCriteria(); studyStorageSearchCriteria.QueueStudyStateEnum.EqualTo(QueueStudyStateEnum.Idle); fsQueueCriteria.StudyStorage.Exists(studyStorageSearchCriteria); fsQueueCriteria.ScheduledTime.SortAsc(0); IList<FilesystemQueue> list = broker.Find(fsQueueCriteria, 0, ServiceLockSettings.Default.FilesystemQueueResultCount); return list; } }
public IList<FilesystemQueue> GetFileSystemQueueItems(Study study) { Platform.CheckForNullReference(study, "Study"); FileSystemQueueAdaptor adaptor = new FileSystemQueueAdaptor(); FilesystemQueueSelectCriteria fileSystemQueueCriteria = new FilesystemQueueSelectCriteria(); fileSystemQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey); fileSystemQueueCriteria.ScheduledTime.SortAsc(0); return adaptor.Get(fileSystemQueueCriteria); }
public FilesystemQueueSelectCriteria(FilesystemQueueSelectCriteria other) : base(other) {}
/// <summary> /// Reprocess a specific study. /// </summary> /// <param name="partition">The ServerPartition the study is on.</param> /// <param name="location">The storage location of the study to process.</param> /// <param name="engine">The rules engine to use when processing the study.</param> /// <param name="postArchivalEngine">The rules engine used for studies that have been archived.</param> /// <param name="dataAccessEngine">The rules engine strictly used for setting data acess.</param> protected static void ProcessStudy(ServerPartition partition, StudyStorageLocation location, ServerRulesEngine engine, ServerRulesEngine postArchivalEngine, ServerRulesEngine dataAccessEngine) { if (!location.QueueStudyStateEnum.Equals(QueueStudyStateEnum.Idle) || !location.AcquireWriteLock()) { Platform.Log(LogLevel.Error, "Unable to lock study {0}. The study is being processed. (Queue State: {1})", location.StudyInstanceUid,location.QueueStudyStateEnum.Description); } else { try { DicomFile msg = LoadInstance(location); if (msg == null) { Platform.Log(LogLevel.Error, "Unable to load file for study {0}", location.StudyInstanceUid); return; } bool archiveQueueExists; bool archiveStudyStorageExists; bool filesystemDeleteExists; using (IReadContext read = PersistentStoreRegistry.GetDefaultStore().OpenReadContext()) { // Check for existing archive queue entries var archiveQueueBroker = read.GetBroker<IArchiveQueueEntityBroker>(); var archiveQueueCriteria = new ArchiveQueueSelectCriteria(); archiveQueueCriteria.StudyStorageKey.EqualTo(location.Key); archiveQueueExists = archiveQueueBroker.Count(archiveQueueCriteria) > 0; var archiveStorageBroker = read.GetBroker<IArchiveStudyStorageEntityBroker>(); var archiveStudyStorageCriteria = new ArchiveStudyStorageSelectCriteria(); archiveStudyStorageCriteria.StudyStorageKey.EqualTo(location.Key); archiveStudyStorageExists = archiveStorageBroker.Count(archiveStudyStorageCriteria) > 0; var filesystemQueueBroker = read.GetBroker<IFilesystemQueueEntityBroker>(); var filesystemQueueCriteria = new FilesystemQueueSelectCriteria(); filesystemQueueCriteria.StudyStorageKey.EqualTo(location.Key); filesystemQueueCriteria.FilesystemQueueTypeEnum.EqualTo(FilesystemQueueTypeEnum.DeleteStudy); filesystemDeleteExists = filesystemQueueBroker.Count(filesystemQueueCriteria) > 0; } using (var commandProcessor = new ServerCommandProcessor("Study Rule Processor")) { var context = new ServerActionContext(msg, location.FilesystemKey, partition, location.Key, commandProcessor); // Check if the Study has been archived if (archiveStudyStorageExists && !archiveQueueExists && !filesystemDeleteExists) { // Add a command to delete the current filesystemQueue entries, so that they can // be reinserted by the rules engine. context.CommandProcessor.AddCommand(new DeleteFilesystemQueueCommand(location.Key, ServerRuleApplyTimeEnum.StudyArchived)); // How to deal with exiting FilesystemQueue entries is problematic here. If the study // has been migrated off tier 1, we probably don't want to modify the tier migration // entries. Compression entries may have been entered when the Study was initially // processed, we don't want to delete them, because they might still be valid. // We just re-run the rules engine at this point, and delete only the StudyPurge entries, // since those we know at least would only be applied for archived studies. var studyRulesEngine = new StudyRulesEngine(postArchivalEngine, location, location.ServerPartition, location.LoadStudyXml()); studyRulesEngine.Apply(ServerRuleApplyTimeEnum.StudyArchived, commandProcessor); // Post Archive doesn't allow data access rules. Force Data Access rules to be reapplied // to these studies also. dataAccessEngine.Execute(context); } else { // Add a command to delete the current filesystemQueue entries, so that they can // be reinserted by the rules engine. context.CommandProcessor.AddCommand(new DeleteFilesystemQueueCommand(location.Key,ServerRuleApplyTimeEnum.StudyProcessed)); // Execute the rules engine, insert commands to update the database into the command processor. // Due to ticket #11673, we create a new rules engine instance for each study, since the Study QC rules // don't work right now with a single rules engine. //TODO CR (Jan 2014) - Check if we can go back to caching the rules engine to reduce database hits on the rules var studyRulesEngine = new StudyRulesEngine(location, location.ServerPartition, location.LoadStudyXml()); studyRulesEngine.Apply(ServerRuleApplyTimeEnum.StudyProcessed, commandProcessor); } // Do the actual database updates. if (false == context.CommandProcessor.Execute()) { Platform.Log(LogLevel.Error, "Unexpected failure processing Study level rules for study {0}", location.StudyInstanceUid); } // Log the FilesystemQueue related entries location.LogFilesystemQueue(); } } finally { location.ReleaseWriteLock(); } } }
public FilesystemQueueSelectCriteria(FilesystemQueueSelectCriteria other) : base(other) { }