static public PartitionTransferSyntax Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
public void Dispose() { try { if (!DirectoryUtility.DeleteIfEmpty(_backupDirectory)) { Platform.Log(LogLevel.Warn, "Some backup files can be found left in {0}", BackupDirectory); } if (Platform.IsLogLevelEnabled(LogLevel.Debug) && Directory.Exists(_tempDirectory)) { Platform.Log(LogLevel.Debug, "Deleting temp folder: {0}", _tempDirectory); } DirectoryUtility.DeleteIfEmpty(_tempDirectory); } finally { if (_updateContext != null) { Rollback(); } if (_readContext != null) { _readContext.Dispose(); _readContext = null; } // reset the current context for the thread _current = _inheritFrom; } }
static public ServerSopClass Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
static public StudyIntegrityQueueUid Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
static public FilesystemStudyStorage Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
static public RequestAttributes Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
static public ProcedureCode Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
/// <summary> /// Validates the state of the study. /// </summary> /// <param name="context">Name of the application</param> /// <param name="studyStorage">The study to validate</param> /// <param name="modes">Specifying what validation to execute</param> public void ValidateStudyState(String context, StudyStorageLocation studyStorage, StudyIntegrityValidationModes modes) { Platform.CheckForNullReference(studyStorage, "studyStorage"); if (modes == StudyIntegrityValidationModes.None) return; using (var scope = new ServerExecutionContext()) { // Force a re-load, the study may have changed if a delete happened. Study study = Study.Find(scope.PersistenceContext, studyStorage.Key); if (study!=null) { StudyXml studyXml = studyStorage.LoadStudyXml(); if (modes == StudyIntegrityValidationModes.Default || (modes & StudyIntegrityValidationModes.InstanceCount) == StudyIntegrityValidationModes.InstanceCount) { if (studyXml != null && studyXml.NumberOfStudyRelatedInstances != study.NumberOfStudyRelatedInstances) { var validationStudyInfo = new ValidationStudyInfo(study, studyStorage.ServerPartition); throw new StudyIntegrityValidationFailure( ValidationErrors.InconsistentObjectCount, validationStudyInfo, String.Format("Number of instances in database and xml do not match: {0} vs {1}.", study.NumberOfStudyRelatedInstances, studyXml.NumberOfStudyRelatedInstances )); } } } } }
static public DataAccessGroup Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
static public ArchiveQueue Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
public ServerExecutionContext(String contextId, ServerExecutionContext inheritFrom) { Platform.CheckForNullReference(contextId, "contextId"); _contextId = contextId; _inheritFrom = inheritFrom; _current = this; }
/// <summary> /// Finds all <see cref="ServiceLock"/> of the specified <see cref="ServiceLockTypeEnum"/> /// </summary> /// <param name="type"></param> /// <returns></returns> public static IList<ServiceLock> FindServicesOfType(ServiceLockTypeEnum type) { using (var context = new ServerExecutionContext()) { var broker = context.ReadContext.GetBroker<IServiceLockEntityBroker>(); var criteria = new ServiceLockSelectCriteria(); criteria.ServiceLockTypeEnum.EqualTo(type); return broker.Find(criteria); } }
public IList<Study> LoadRelatedStudies() { using (var context = new ServerExecutionContext()) { IStudyEntityBroker broker = context.ReadContext.GetBroker<IStudyEntityBroker>(); StudySelectCriteria criteria = new StudySelectCriteria(); criteria.PatientKey.EqualTo(Key); return broker.Find(criteria); } }
private void LoadAdditionalEntities() { Debug.Assert(ServerPartition != null); Debug.Assert(StorageLocation != null); using (ServerExecutionContext context = new ServerExecutionContext()) { if (_filesystem != null) _filesystem = FilesystemMonitor.Instance.GetFilesystemInfo(StorageLocation.FilesystemKey); _study = StorageLocation.LoadStudy(context.ReadContext); _patient = Patient.Load(context.ReadContext, _study.PatientKey); } }
public Study GetStudy() { if (_study == null) { lock (SyncRoot) { using (var context = new ServerExecutionContext()) { _study = LoadStudy(context.ReadContext); } } } return _study; }
private void LoadRelatedEntities() { if (_study==null || _studyStorage==null) { using (var context = new ServerExecutionContext()) { lock (SyncRoot) { if (_study == null) _study = LoadStudy(context.ReadContext); if (_studyStorage == null) _studyStorage = LoadStudyStorage(context.ReadContext); } } } }
/// <summary> /// Finds a list of <see cref="WorkQueue"/> related to the specified <see cref="studyStorageKey"/>. /// </summary> /// <param name="studyStorageKey"></param> /// <param name="filter">A delegate that will be used to filter the returned list. Pass in Null to get the entire list.</param> /// <returns>A list of <see cref="WorkQueue"/></returns> static public IList<WorkQueue> FindWorkQueueEntries(ServerEntityKey studyStorageKey, Predicate<WorkQueue> filter) { Platform.CheckForNullReference(studyStorageKey, "studyStorageKey"); using (var scope = new ServerExecutionContext()) { var broker = scope.PersistenceContext.GetBroker<IWorkQueueEntityBroker>(); var criteria = new WorkQueueSelectCriteria(); criteria.StudyStorageKey.EqualTo(studyStorageKey); criteria.InsertTime.SortDesc(0); IList<WorkQueue> list = broker.Find(criteria); if (filter != null) { CollectionUtils.Remove(list, filter); } return list; } }
/// <summary> /// Checks for the existinance of a SOP for a given Study in the <see cref="WorkQueue"/> for a <see cref="WorkQueueTypeEnum.ReconcileStudy"/>. /// </summary> /// <param name="studyStorageKey">The StudyStorage primary key</param> /// <param name="seriesInstanceUid">The Series Instance Uid of the Sop</param> /// <param name="sopInstanceUid">The Sop Instance to look for</param> /// <returns>true if an entry exists, false if it doesn't</returns> static public bool WorkQueueUidExists(ServerEntityKey studyStorageKey, string seriesInstanceUid, string sopInstanceUid) { Platform.CheckForNullReference(studyStorageKey, "studyStorageKey"); using (var scope = new ServerExecutionContext()) { var broker = scope.PersistenceContext.GetBroker<IWorkQueueEntityBroker>(); var uidSelectCriteria = new WorkQueueUidSelectCriteria(); uidSelectCriteria.SeriesInstanceUid.EqualTo(seriesInstanceUid); uidSelectCriteria.SopInstanceUid.EqualTo(sopInstanceUid); var selectCriteria = new WorkQueueSelectCriteria(); selectCriteria.StudyStorageKey.EqualTo(studyStorageKey); selectCriteria.WorkQueueTypeEnum.EqualTo(WorkQueueTypeEnum.ReconcileStudy); selectCriteria.WorkQueueUidRelatedEntityCondition.Exists(uidSelectCriteria); return broker.Count(selectCriteria) > 0; } }
/// <summary> /// Finds a list of <see cref="StudyHistory"/> records of the specified <see cref="StudyHistoryTypeEnum"/> /// for the specified <see cref="StudyStorage"/>. /// </summary> /// <param name="studyStorage"></param> /// <returns></returns> /// <param name="types"></param> static public IList<StudyHistory> FindStudyHistories(StudyStorage studyStorage, IEnumerable<StudyHistoryTypeEnum> types) { // Use of ExecutionContext to re-use db connection if possible using (ServerExecutionContext scope = new ServerExecutionContext()) { IStudyHistoryEntityBroker broker = scope.PersistenceContext.GetBroker<IStudyHistoryEntityBroker>(); StudyHistorySelectCriteria criteria = new StudyHistorySelectCriteria(); criteria.StudyStorageKey.EqualTo(studyStorage.Key); criteria.StudyHistoryTypeEnum.EqualTo(StudyHistoryTypeEnum.StudyReconciled); if (types != null) { criteria.StudyHistoryTypeEnum.In(types); } criteria.InsertTime.SortAsc(0); IList<StudyHistory> historyList = broker.Find(criteria); return historyList; } }
public string GetFolderPath() { if (_location == null) { if (_studyStorage == null) { using (var context = new ServerExecutionContext()) { _studyStorage = StudyStorage.Load(context.ReadContext, this.StudyStorageKey); } } _location = StudyStorageLocation.FindStorageLocations(_studyStorage)[0]; } XmlNode nodeStoragePath = Data.SelectSingleNode("//StoragePath"); String path = Path.Combine(_location.FilesystemPath, _location.PartitionFolder); path = Path.Combine(path, "Reconcile"); path = Path.Combine(path, nodeStoragePath.InnerText); return path; }
/// <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; } }
/// <summary> /// Returns number of Delete Study, Tier Migrate, and Study Purge work queue items /// that are still Pending or In Progress for the filesystem associated with the /// specified <see cref="ServiceLock"/>. /// </summary> /// <param name="item">The ServiceLock item.</param> /// <returns>The number of WorkQueue entries pending.</returns> private int CheckWorkQueueCount(Model.ServiceLock item) { using (ServerExecutionContext context = new ServerExecutionContext()) { IWorkQueueEntityBroker select = context.ReadContext.GetBroker<IWorkQueueEntityBroker>(); WorkQueueSelectCriteria criteria = new WorkQueueSelectCriteria(); criteria.WorkQueueTypeEnum.In(new[] { WorkQueueTypeEnum.DeleteStudy, WorkQueueTypeEnum.MigrateStudy, WorkQueueTypeEnum.PurgeStudy }); // Do Pending status, in case there's a Failure status entry, we don't want to // block on that. criteria.WorkQueueStatusEnum.In(new[] {WorkQueueStatusEnum.Pending, WorkQueueStatusEnum.InProgress}); FilesystemStudyStorageSelectCriteria filesystemCriteria = new FilesystemStudyStorageSelectCriteria(); filesystemCriteria.FilesystemKey.EqualTo(item.FilesystemKey); criteria.FilesystemStudyStorageRelatedEntityCondition.Exists(filesystemCriteria); int count = select.Count(criteria); return count; } }
/// <summary> /// Load the <see cref="ServerRulesEngine"/> for each partition. /// </summary> private void LoadRulesEngine() { using (var context = new ServerExecutionContext()) { var broker = context.ReadContext.GetBroker<IServerPartitionEntityBroker>(); var criteria = new ServerPartitionSelectCriteria(); IList<ServerPartition> partitions = broker.Find(criteria); foreach (ServerPartition partition in partitions) { //TODO CR (Jan 2014) - Cached engine not being used now, due to #11673 var engine = new ServerRulesEngine(ServerRuleApplyTimeEnum.StudyProcessed, partition.Key); engine.Load(); _engines.Add(partition, engine); engine = new ServerRulesEngine(ServerRuleApplyTimeEnum.StudyArchived, partition.Key); engine.Load(); _postArchivalEngines.Add(partition, engine); engine = new ServerRulesEngine(ServerRuleApplyTimeEnum.StudyProcessed, partition.Key); engine.AddIncludeType(ServerRuleTypeEnum.DataAccess); engine.Load(); _dataAccessEngine.Add(partition, engine); } } }
protected override void OnProcess(Model.ServiceLock item) { _store = PersistentStoreRegistry.GetDefaultStore(); using (ServerExecutionContext context = new ServerExecutionContext()) { IServerPartitionEntityBroker broker = context.ReadContext.GetBroker<IServerPartitionEntityBroker>(); ServerPartitionSelectCriteria criteria = new ServerPartitionSelectCriteria(); criteria.AeTitle.SortAsc(0); _partitions = broker.Find(criteria); } ServerFilesystemInfo info = FilesystemMonitor.Instance.GetFilesystemInfo(item.FilesystemKey); Platform.Log(LogLevel.Info, "Starting reinventory of filesystem: {0}", info.Filesystem.Description); ReinventoryFilesystem(info.Filesystem); item.ScheduledTime = item.ScheduledTime.AddDays(1); if (CancelPending) { Platform.Log(LogLevel.Info, "Filesystem Reinventory of {0} has been canceled, rescheduling. Note that the entire Filesystem will be reinventoried again.", info.Filesystem.Description); UnlockServiceLock(item, true, Platform.Time.AddMinutes(1)); } else { Platform.Log(LogLevel.Info, "Filesystem Reinventory of {0} has completed.", info.Filesystem.Description); UnlockServiceLock(item, false, Platform.Time.AddDays(1)); } }
private static bool GetStudyStorage(ServerPartition partition, string studyInstanceUid, out StudyStorage storage) { using (ServerExecutionContext context = new ServerExecutionContext()) { storage = StudyStorage.Load(context.ReadContext, partition.Key, studyInstanceUid); if (storage != null) return true; return false; } }
private void ReinventoryFilesystem(Filesystem filesystem) { ServerPartition partition; DirectoryInfo filesystemDir = new DirectoryInfo(filesystem.FilesystemPath); foreach(DirectoryInfo partitionDir in filesystemDir.GetDirectories()) { if (GetServerPartition(partitionDir.Name, out partition) == false) continue; foreach(DirectoryInfo dateDir in partitionDir.GetDirectories()) { if (dateDir.FullName.EndsWith("Deleted", StringComparison.InvariantCultureIgnoreCase) || dateDir.FullName.EndsWith(ServerPlatform.ReconcileStorageFolder, StringComparison.InvariantCultureIgnoreCase)) continue; List<FileInfo> fileList; foreach (DirectoryInfo studyDir in dateDir.GetDirectories()) { if (studyDir.FullName.EndsWith("Deleted", StringComparison.InvariantCultureIgnoreCase)) continue; // Check for Cancel message if (CancelPending) return; String studyInstanceUid = studyDir.Name; StudyStorageLocation location; if (GetStudyStorageLocation(partition.Key, studyInstanceUid, out location)) { #region Study record exists in db int integrityQueueCount; int workQueueCount; Study theStudy = GetStudyAndQueues(location, out integrityQueueCount, out workQueueCount); if (theStudy != null) continue; if (integrityQueueCount != 0 && workQueueCount != 0) continue; fileList = LoadSopFiles(studyDir, false); if (fileList.Count == 0) { Platform.Log(LogLevel.Warn, "Found empty study folder with StorageLocation, deleteing StorageLocation: {0}\\{1}", dateDir.Name, studyDir.Name); studyDir.Delete(true); RemoveStudyStorage(location); continue; } // WriteLock the new study storage for study processing if (!location.QueueStudyStateEnum.Equals(QueueStudyStateEnum.ProcessingScheduled)) { string failureReason; if (!ServerHelper.LockStudy(location.Key,QueueStudyStateEnum.ProcessingScheduled, out failureReason)) Platform.Log(LogLevel.Error, "Unable to lock study {0} for Study Processing", location.StudyInstanceUid); } #endregion } else { #region Directory not in DB, fileList = LoadSopFiles(studyDir, true); if (fileList.Count == 0) { Platform.Log(LogLevel.Warn, "Found empty study folder: {0}\\{1}", dateDir.Name, studyDir.Name); continue; } DicomFile file = LoadFileFromList(fileList); if (file == null) { Platform.Log(LogLevel.Warn, "Found directory with no readable files: {0}\\{1}", dateDir.Name, studyDir.Name); continue; } // Do a second check, using the study instance uid from a file in the directory. // had an issue with trailing periods on uids causing us to not find the // study storage, and insert a new record into the database. studyInstanceUid = file.DataSet[DicomTags.StudyInstanceUid].ToString(); if (GetStudyStorageLocation(partition.Key, studyInstanceUid, out location)) { continue; } StudyStorage storage; if (GetStudyStorage(partition, studyInstanceUid, out storage)) { Platform.Log(LogLevel.Warn, "Study {0} on filesystem partition {1} is offline {2}", studyInstanceUid, partition.Description, studyDir.ToString()); continue; } Platform.Log(LogLevel.Info, "Reinventory inserting study storage location for {0} on partition {1}", studyInstanceUid, partition.Description); // Insert StudyStorage using (IUpdateContext update = _store.OpenUpdateContext(UpdateContextSyncMode.Flush)) { IInsertStudyStorage studyInsert = update.GetBroker<IInsertStudyStorage>(); InsertStudyStorageParameters insertParms = new InsertStudyStorageParameters { ServerPartitionKey = partition.GetKey(), StudyInstanceUid = studyInstanceUid, Folder = dateDir.Name, FilesystemKey = filesystem.GetKey(), QueueStudyStateEnum = QueueStudyStateEnum.Idle }; if (file.TransferSyntax.LosslessCompressed) { insertParms.TransferSyntaxUid = file.TransferSyntax.UidString; insertParms.StudyStatusEnum = StudyStatusEnum.OnlineLossless; } else if (file.TransferSyntax.LossyCompressed) { insertParms.TransferSyntaxUid = file.TransferSyntax.UidString; insertParms.StudyStatusEnum = StudyStatusEnum.OnlineLossy; } else { insertParms.TransferSyntaxUid = file.TransferSyntax.UidString; insertParms.StudyStatusEnum = StudyStatusEnum.Online; } location = studyInsert.FindOne(insertParms); // WriteLock the new study storage for study processing ILockStudy lockStudy = update.GetBroker<ILockStudy>(); LockStudyParameters lockParms = new LockStudyParameters { StudyStorageKey = location.Key, QueueStudyStateEnum = QueueStudyStateEnum.ProcessingScheduled }; if (!lockStudy.Execute(lockParms) || !lockParms.Successful) Platform.Log(LogLevel.Error, "Unable to lock study {0} for Study Processing", location.StudyInstanceUid); update.Commit(); } #endregion } string studyXml = location.GetStudyXmlPath(); if (File.Exists(studyXml)) FileUtils.Delete(studyXml); string studyGZipXml = location.GetCompressedStudyXmlPath(); if (File.Exists(studyGZipXml)) FileUtils.Delete(studyGZipXml); foreach (FileInfo sopFile in fileList) { String sopInstanceUid = sopFile.Name.Replace(sopFile.Extension, string.Empty); using (ServerExecutionContext context = new ServerExecutionContext()) { // Just use a read context here, in hopes of improving // performance. Every other place in the code should use // Update contexts when doing transactions. IInsertWorkQueue workQueueInsert = context.ReadContext.GetBroker<IInsertWorkQueue>(); InsertWorkQueueParameters queueInsertParms = new InsertWorkQueueParameters { WorkQueueTypeEnum = WorkQueueTypeEnum.StudyProcess, StudyStorageKey = location.GetKey(), ServerPartitionKey = partition.GetKey(), SeriesInstanceUid = sopFile.Directory.Name, SopInstanceUid = sopInstanceUid, ScheduledTime = Platform.Time }; if (workQueueInsert.FindOne(queueInsertParms) == null) Platform.Log(LogLevel.Error, "Failure attempting to insert SOP Instance into WorkQueue during Reinventory."); } } } // Cleanup the date directory, if its empty. DirectoryUtility.DeleteIfEmpty(dateDir.FullName); } } }
/// <summary> /// Load the specific SOP Instance Uids in the database for the WorkQueue item. /// </summary> /// <param name="item">The WorkQueue item.</param> protected void LoadUids(Model.WorkQueue item) { if (_uidList==null) { UidsLoadTime.Add(delegate { using (ServerExecutionContext context = new ServerExecutionContext()) { IWorkQueueUidEntityBroker select = context.ReadContext.GetBroker<IWorkQueueUidEntityBroker>(); WorkQueueUidSelectCriteria parms = new WorkQueueUidSelectCriteria(); parms.WorkQueueKey.EqualTo(item.GetKey()); _uidList = select.Find(parms); _uidList = TruncateList(item, _uidList); } } ); } }
static public ExternalRequestQueue Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }
private ReconcileStudyQueueDescription CreateQueueEntryDescription(DicomFile file) { using(var context = new ServerExecutionContext()) { Study study = _studyLocation.LoadStudy(context.PersistenceContext); if (study!=null) { var desc = new ReconcileStudyQueueDescription { ExistingPatientId = study.PatientId, ExistingPatientName = study.PatientsName, ExistingAccessionNumber = study.AccessionNumber, ConflictingPatientName = file.DataSet[DicomTags.PatientsName].ToString(), ConflictingPatientId = file.DataSet[DicomTags.PatientId].ToString(), ConflictingAccessionNumber = file.DataSet[DicomTags.AccessionNumber].ToString() }; return desc; } return null; } }
/// <summary> /// Process a <see cref="WorkQueue"/> item of type AutoRoute. /// </summary> protected override void ProcessItem(Model.WorkQueue item) { if (WorkQueueItem.ScheduledTime >= WorkQueueItem.ExpirationTime && !HasPendingItems) { Platform.Log(LogLevel.Debug, "Removing Idle {0} entry : {1}", item.WorkQueueTypeEnum, item.GetKey().Key); base.PostProcessing(item, WorkQueueProcessorStatus.Complete, WorkQueueProcessorDatabaseUpdate.None); return; } if (!HasPendingItems) { // nothing to process, change to idle state PostProcessing(item, WorkQueueProcessorStatus.Idle, WorkQueueProcessorDatabaseUpdate.None); return; } Platform.Log(LogLevel.Info, "Moving study {0} for Patient {1} (PatientId:{2} A#:{3}) on Partition {4} to {5}...", Study.StudyInstanceUid, Study.PatientsName, Study.PatientId, Study.AccessionNumber, ServerPartition.Description, DestinationDevice.AeTitle); // Load remote device information from the database. Device device = DestinationDevice; if (device == null) { item.FailureDescription = String.Format("Unknown auto-route destination \"{0}\"", item.DeviceKey); Platform.Log(LogLevel.Error, item.FailureDescription); PostProcessingFailure(item, WorkQueueProcessorFailureType.Fatal); // Fatal Error return; } if (device.Dhcp && device.IpAddress.Length == 0) { item.FailureDescription = String.Format("Auto-route destination is a DHCP device with no known IP address: \"{0}\"", device.AeTitle); Platform.Log(LogLevel.Error, item.FailureDescription); PostProcessingFailure(item, WorkQueueProcessorFailureType.Fatal); // Fatal error return; } // Now setup the StorageSCU component int sendCounter = 0; using (ImageServerStorageScu scu = new ImageServerStorageScu(ServerPartition, device)) { using (ServerExecutionContext context = new ServerExecutionContext()) // set the preferred syntax lists scu.LoadPreferredSyntaxes(context.ReadContext); // Load the Instances to Send into the SCU component scu.AddStorageInstanceList(InstanceList); // Set an event to be called when each image is transferred scu.ImageStoreCompleted += delegate(Object sender, StorageInstance instance) { if (instance.SendStatus.Status == DicomState.Success || instance.SendStatus.Status == DicomState.Warning || instance.SendStatus.Equals(DicomStatuses.SOPClassNotSupported)) { sendCounter++; OnInstanceSent(instance); } if (instance.SendStatus.Status == DicomState.Failure) { scu.FailureDescription = instance.SendStatus.Description; if (false == String.IsNullOrEmpty(instance.ExtendedFailureDescription)) { scu.FailureDescription = String.Format("{0} [{1}]", scu.FailureDescription, instance.ExtendedFailureDescription); } } if (CancelPending && !(this is WebMoveStudyItemProcessor) && !scu.Canceled) { Platform.Log(LogLevel.Info, "Auto-route canceled due to shutdown for study: {0}", StorageLocation.StudyInstanceUid); item.FailureDescription = "Operation was canceled due to server shutdown request."; scu.Cancel(); } }; try { // Block until send is complete scu.Send(); // Join for the thread to exit scu.Join(); } catch (Exception ex) { Platform.Log(LogLevel.Error, ex, "Error occurs while sending images to {0} : {1}", device.AeTitle, ex.Message); } finally { if (scu.FailureDescription.Length > 0) { item.FailureDescription = scu.FailureDescription; scu.Status = ScuOperationStatus.Failed; } // Reset the WorkQueue entry status if ((InstanceList.Count > 0 && sendCounter != InstanceList.Count) // not all sop were sent || scu.Status == ScuOperationStatus.Failed || scu.Status == ScuOperationStatus.ConnectFailed) { PostProcessingFailure(item, WorkQueueProcessorFailureType.NonFatal); // failures occurred} } else { OnComplete(); } } } }
static public ServerPartitionAlternateAeTitle Load(ServerEntityKey key) { using (var context = new ServerExecutionContext()) { return Load(context.ReadContext, key); } }