private static void UpdateFilesystemKey(Model.ServiceLock item)
{
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
ServiceLockUpdateColumns columns = new ServiceLockUpdateColumns();
columns.FilesystemKey = item.FilesystemKey;
IServiceLockEntityBroker broker = ctx.GetBroker <IServiceLockEntityBroker>();
broker.Update(item.Key, columns);
ctx.Commit();
}
}
public void EventHandler(object sender, StudyEditedEventArgs e)
{
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
Platform.Log(LogLevel.Info, "Logging study history record...");
IStudyHistoryEntityBroker broker = ctx.GetBroker<IStudyHistoryEntityBroker>();
StudyHistoryUpdateColumns recordColumns = CreateStudyHistoryRecord(e);
StudyHistory entry = broker.Insert(recordColumns);
if (entry != null)
ctx.Commit();
else
throw new ApplicationException("Unable to log study history record");
}
}
private void Apply_Click(object sender, EventArgs e)
{
var view = dataGridView1.SelectedRows[0].DataBoundItem as DataRowView;
if (view != null)
{
var guid = (Guid)view.Row["GUID"];
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
var studyBroker = ctx.GetBroker <IStudyEntityBroker>();
var key = new ServerEntityKey("Study", guid);
Model.Study study = studyBroker.Load(key);
var storageBroker = ctx.GetBroker <IStudyStorageEntityBroker>();
var parms = new StudyStorageSelectCriteria();
parms.ServerPartitionKey.EqualTo(study.ServerPartitionKey);
parms.StudyInstanceUid.EqualTo(study.StudyInstanceUid);
Model.StudyStorage storage = storageBroker.Find(parms)[0];
var workQueueBroker = ctx.GetBroker <IWorkQueueEntityBroker>();
var columns = new WorkQueueUpdateColumns
{
ServerPartitionKey = study.ServerPartitionKey,
StudyStorageKey = storage.GetKey(),
ExpirationTime = DateTime.Now.AddHours(1),
ScheduledTime = DateTime.Now,
InsertTime = DateTime.Now,
WorkQueuePriorityEnum = Model.WorkQueuePriorityEnum.Medium,
WorkQueueStatusEnum = Model.WorkQueueStatusEnum.Pending,
WorkQueueTypeEnum = Model.WorkQueueTypeEnum.WebEditStudy
};
var doc = new XmlDocument();
doc.Load(new StringReader(textBox1.Text));
columns.Data = doc;
workQueueBroker.Insert(columns);
ctx.Commit();
}
}
}
/// <summary>
/// Creates a Study Reprocess entry and locks the study in <see cref="QueueStudyStateEnum.ReprocessScheduled"/> state.
/// </summary>
/// <param name="reason"></param>
/// <param name="location"></param>
/// <param name="scheduleTime"></param>
/// <returns></returns>
/// <exception cref="InvalidStudyStateOperationException">Study is in a state that reprocessing is not allowed</exception>
public WorkQueue ReprocessStudy(String reason, StudyStorageLocation location, DateTime scheduleTime)
{
Platform.CheckForNullReference(location, "location");
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
WorkQueue reprocessEntry = ReprocessStudy(ctx, reason, location, scheduleTime);
if (reprocessEntry != null)
{
ctx.Commit();
}
return(reprocessEntry);
}
}
public bool ResetArchiveQueueItem(IList <ArchiveQueue> items, DateTime time)
{
if (items == null || items.Count == 0)
{
return(false);
}
ArchiveQueueUpdateColumns columns = new ArchiveQueueUpdateColumns();
columns.ArchiveQueueStatusEnum = ArchiveQueueStatusEnum.Pending;
columns.ProcessorId = "";
columns.ScheduledTime = time;
bool result = true;
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IArchiveQueueEntityBroker archiveQueueBroker = ctx.GetBroker <IArchiveQueueEntityBroker>();
foreach (ArchiveQueue item in items)
{
// Only do an update if its a failed status currently
ArchiveQueueSelectCriteria criteria = new ArchiveQueueSelectCriteria();
criteria.ArchiveQueueStatusEnum.EqualTo(ArchiveQueueStatusEnum.Failed);
criteria.StudyStorageKey.EqualTo(item.StudyStorageKey);
if (!archiveQueueBroker.Update(criteria, columns))
{
result = false;
break;
}
}
if (result)
{
ctx.Commit();
}
}
return(result);
}
private void LogHistory(ImageSetDetails details)
{
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
Platform.Log(LogLevel.Info, "Logging study history record...");
IStudyHistoryEntityBroker broker = ctx.GetBroker <IStudyHistoryEntityBroker>();
StudyHistoryUpdateColumns recordColumns = CreateStudyHistoryRecord(details);
StudyHistory entry = broker.Insert(recordColumns);
if (entry != null)
{
ctx.Commit();
}
else
{
throw new ApplicationException("Unable to log study history record");
}
}
HistoryLogged = true;
}
/// <summary>
/// Reschedule a list of <see cref="WorkQueue"/> items
/// </summary>
/// <param name="items">List of <see cref="WorkQueue"/> items to be rescheduled</param>
/// <param name="newScheduledTime">New schedule start date/time</param>
/// <param name="expirationTime">New expiration date/time</param>
/// <param name="priority">New priority</param>
/// <returns>A value indicating whether all <see cref="WorkQueue"/> items in <paramref name="items"/> are updated successfully.</returns>
/// <remarks>
/// If one or more <see cref="WorkQueue"/> in <paramref name="items"/> cannot be rescheduled, all changes will be
/// reverted and <b>false</b> will be returned.
/// </remarks>
public bool RescheduleWorkQueueItems(IList <WorkQueue> items, DateTime newScheduledTime, DateTime expirationTime, WorkQueuePriorityEnum priority)
{
if (items == null || items.Count == 0)
{
return(false);
}
WorkQueueUpdateColumns updatedColumns = new WorkQueueUpdateColumns();
updatedColumns.WorkQueuePriorityEnum = priority;
updatedColumns.ScheduledTime = newScheduledTime;
updatedColumns.ExpirationTime = expirationTime;
updatedColumns.FailureCount = 0;
updatedColumns.FailureDescription = String.Empty;
updatedColumns.LastUpdatedTime = Platform.Time;
bool result = false;
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IWorkQueueEntityBroker workQueueBroker = ctx.GetBroker <IWorkQueueEntityBroker>();
foreach (WorkQueue item in items)
{
result = workQueueBroker.Update(item.Key, updatedColumns);
if (!result)
{
break;
}
}
if (result)
{
ctx.Commit();
}
}
return(result);
}
/// <summary>
/// Deletes a list of <see cref="WorkQueue"/> items from the system.
/// </summary>
/// <param name="items">The list of <see cref="WorkQueue"/> items to be deleted</param>
/// <returns>A value indicating whether all items have been successfully deleted.</returns>
///
/// <remarks>
/// If one or more <see cref="WorkQueue"/> in <paramref name="items"/> cannot be deleted, the method will return <b>false</b>
/// and the deletion will be undone (i.e., All of the <see cref="WorkQueue"/> items will remain in the database)
/// </remarks>
public bool DeleteWorkQueueItems(IList <WorkQueue> items)
{
if (items == null || items.Count == 0)
{
return(false);
}
bool result = true;
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext uctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IDeleteWorkQueue delete = uctx.GetBroker <IDeleteWorkQueue>();
foreach (WorkQueue item in items)
{
WorkQueueDeleteParameters parms = new WorkQueueDeleteParameters();
parms.ServerPartitionKey = item.ServerPartitionKey;
parms.StudyStorageKey = item.StudyStorageKey;
parms.WorkQueueKey = item.Key;
parms.WorkQueueTypeEnum = item.WorkQueueTypeEnum;
// NOTE: QueueStudyState is reset by the stored procedure
if (!delete.Execute(parms))
{
Platform.Log(LogLevel.Error, "Unexpected error trying to delete WorkQueue entry");
result = false;
}
}
if (result)
{
uctx.Commit();
}
}
return(result);
}
private static void WriteToDatabase(ImageServer.Common.Alert alert)
{
XmlDocument doc = CreateXmlContent(alert);
AlertUpdateColumns columns = new AlertUpdateColumns();
columns.AlertCategoryEnum = AlertCategoryEnum.GetEnum(alert.Category.ToString());
columns.AlertLevelEnum = AlertLevelEnum.GetEnum(alert.Level.ToString());
columns.Component = alert.Source.Name;
columns.Content = doc;
columns.InsertTime = Platform.Time;
columns.Source = alert.Source.Host;
columns.TypeCode = alert.Code;
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IAlertEntityBroker alertBroker = ctx.GetBroker <IAlertEntityBroker>();
alertBroker.Insert(columns);
ctx.Commit();
}
}
public bool ReprocessWorkQueueItem(WorkQueue item)
{
// #10620: Get a list of remaining WorkQueueUids which need to be reprocess
// Note: currently only WorkQueueUIDs in failed StudyProcess will be reprocessed
var remainingWorkQueueUidPaths = item.GetAllWorkQueueUidPaths();
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
// delete current workqueue
IWorkQueueUidEntityBroker uidBroker = ctx.GetBroker <IWorkQueueUidEntityBroker>();
WorkQueueUidSelectCriteria criteria = new WorkQueueUidSelectCriteria();
criteria.WorkQueueKey.EqualTo(item.GetKey());
if (uidBroker.Delete(criteria) >= 0)
{
IWorkQueueEntityBroker workQueueBroker = ctx.GetBroker <IWorkQueueEntityBroker>();
if (workQueueBroker.Delete(item.GetKey()))
{
IList <StudyStorageLocation> locations = item.LoadStudyLocations(ctx);
if (locations != null && locations.Count > 0)
{
StudyReprocessor reprocessor = new StudyReprocessor();
String reason = String.Format("User reprocesses failed {0}", item.WorkQueueTypeEnum);
WorkQueue reprocessEntry = reprocessor.ReprocessStudy(ctx, reason, locations[0], remainingWorkQueueUidPaths, Platform.Time);
if (reprocessEntry != null)
{
ctx.Commit();
}
return(reprocessEntry != null);
}
}
}
}
return(false);
}
/// <summary>
/// The processing thread.
/// </summary>
/// <remarks>
/// This method queries the database for ServiceLock entries to work on, and then uses
/// a thread pool to process the entries.
/// </remarks>
public void Run()
{
// Start the thread pool
if (!_threadPool.Active)
{
_threadPool.Start();
}
// Reset any queue items related to this service that are have the Lock bit set.
try
{
ResetLocked();
}
catch (Exception e)
{
Platform.Log(LogLevel.Fatal, e,
"Unable to reset ServiceLock items on startup. There may be ServiceLock items orphaned in the queue.");
}
Platform.Log(LogLevel.Info, "ServiceLock Processor is running");
while (true)
{
try
{
if (_threadPool.CanQueueItem)
{
Model.ServiceLock queueListItem;
using (IUpdateContext updateContext = _store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IQueryServiceLock select = updateContext.GetBroker <IQueryServiceLock>();
ServiceLockQueryParameters parms = new ServiceLockQueryParameters();
parms.ProcessorId = ServerPlatform.ProcessorId;
queueListItem = select.FindOne(parms);
updateContext.Commit();
}
if (queueListItem == null)
{
WaitHandle.WaitAny(new WaitHandle[] { _terminationEvent, _threadStop }, TimeSpan.FromSeconds(30), false);
_threadStop.Reset();
}
else
{
if (!_extensions.ContainsKey(queueListItem.ServiceLockTypeEnum))
{
Platform.Log(LogLevel.Error,
"No extensions loaded for ServiceLockTypeEnum item type: {0}. Failing item.",
queueListItem.ServiceLockTypeEnum);
//Just fail the ServiceLock item, not much else we can do
ResetServiceLock(queueListItem);
continue;
}
IServiceLockProcessorFactory factory = _extensions[queueListItem.ServiceLockTypeEnum];
IServiceLockItemProcessor processor;
try
{
processor = factory.GetItemProcessor();
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e, "Unexpected exception creating ServiceLock processor.");
ResetServiceLock(queueListItem);
continue;
}
_threadPool.Enqueue(processor, queueListItem, delegate(IServiceLockItemProcessor queueProcessor, Model.ServiceLock queueItem)
{
try
{
queueProcessor.Process(queueItem);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e,
"Unexpected exception when processing ServiceLock item of type {0}. Failing Queue item. (GUID: {1})",
queueItem.ServiceLockTypeEnum,
queueItem.GetKey());
ServerPlatform.Alert(AlertCategory.Application, AlertLevel.Error, "ServiceLockProcessor",
AlertTypeCodes.UnableToProcess,
null, TimeSpan.Zero,
"Exception thrown when processing {0} ServiceLock item : {1}",
queueItem.ServiceLockTypeEnum.Description, e.Message);
ResetServiceLock(queueItem);
}
// Cleanup the processor
queueProcessor.Dispose();
// Signal the thread to come out of sleep mode
_threadStop.Set();
});
}
}
else
{
// Wait for only 5 seconds when the thread pool is all in use.
WaitHandle.WaitAny(new WaitHandle[] { _terminationEvent, _threadStop }, TimeSpan.FromSeconds(5), false);
_threadStop.Reset();
}
}
catch (Exception ex)
{
Platform.Log(LogLevel.Error, ex, "Exception has occurred : {0}. Retry later.", ex.Message);
WaitHandle.WaitAny(new WaitHandle[] { _terminationEvent, _threadStop }, TimeSpan.FromSeconds(5), false);
_threadStop.Reset();
}
if (_stop)
{
return;
}
}
}
/// <summary>
/// Updates the 'State' of the filesystem associated with the 'FilesystemDelete' <see cref="ServiceLock"/> item
/// </summary>
/// <param name="item"></param>
/// <param name="fs"></param>
private static void UpdateState(Model.ServiceLock item, ServerFilesystemInfo fs)
{
FilesystemState state = null;
if (item.State != null && item.State.DocumentElement != null)
{
//load from datatabase
state = XmlUtils.Deserialize <FilesystemState>(item.State.DocumentElement);
}
if (state == null)
{
state = new FilesystemState();
}
if (fs.AboveHighWatermark)
{
// we don't want to generate alert if the filesystem is offline or not accessible.
if (fs.Online && (fs.Readable || fs.Writeable))
{
TimeSpan ALERT_INTERVAL = TimeSpan.FromMinutes(ServiceLockSettings.Default.HighWatermarkAlertInterval);
if (state.AboveHighWatermarkTimestamp == null)
{
state.AboveHighWatermarkTimestamp = Platform.Time;
}
TimeSpan elapse = (state.LastHighWatermarkAlertTimestamp != null) ? Platform.Time - state.LastHighWatermarkAlertTimestamp.Value : Platform.Time - state.AboveHighWatermarkTimestamp.Value;
if (elapse.Duration() >= ALERT_INTERVAL)
{
ServerPlatform.Alert(AlertCategory.System, AlertLevel.Warning, "Filesystem",
AlertTypeCodes.LowResources, null, TimeSpan.Zero,
SR.AlertFilesystemAboveHW,
fs.Filesystem.Description,
TimeSpanFormatter.Format(Platform.Time - state.AboveHighWatermarkTimestamp.Value, true));
state.LastHighWatermarkAlertTimestamp = Platform.Time;
}
}
else
{
state.AboveHighWatermarkTimestamp = null;
state.LastHighWatermarkAlertTimestamp = null;
}
}
else
{
state.AboveHighWatermarkTimestamp = null;
state.LastHighWatermarkAlertTimestamp = null;
}
XmlDocument stateXml = new XmlDocument();
stateXml.AppendChild(stateXml.ImportNode(XmlUtils.Serialize(state), true));
IPersistentStore store = PersistentStoreRegistry.GetDefaultStore();
using (IUpdateContext ctx = store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
ServiceLockUpdateColumns columns = new ServiceLockUpdateColumns();
columns.State = stateXml;
IServiceLockEntityBroker broker = ctx.GetBroker <IServiceLockEntityBroker>();
broker.Update(item.GetKey(), columns);
ctx.Commit();
}
}
/// <summary>
/// Simple routine for failing a work queue item.
/// </summary>
/// <param name="item">The item to fail.</param>
/// <param name="failureDescription">The reason for the failure.</param>
private void FailQueueItem(Model.WorkQueue item, string failureDescription)
{
// Must retry to reset the status of the entry in case of db error
// Failure to do so will create stale work queue entry (stuck in "In Progress" state)
// which can only be recovered by restarting the service.
while (true)
{
try
{
WorkQueueTypeProperties prop = _propertiesDictionary[item.WorkQueueTypeEnum];
using (IUpdateContext updateContext = _store.OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IUpdateWorkQueue update = updateContext.GetBroker <IUpdateWorkQueue>();
UpdateWorkQueueParameters parms = new UpdateWorkQueueParameters
{
ProcessorID = ServerPlatform.ProcessorId,
WorkQueueKey = item.GetKey(),
StudyStorageKey = item.StudyStorageKey,
FailureCount = item.FailureCount + 1,
FailureDescription = failureDescription
};
var settings = WorkQueueSettings.Instance;
if ((item.FailureCount + 1) > prop.MaxFailureCount)
{
Platform.Log(LogLevel.Error,
"Failing {0} WorkQueue entry ({1}), reached max retry count of {2}. Failure Reason: {3}",
item.WorkQueueTypeEnum, item.GetKey(), item.FailureCount + 1, failureDescription);
parms.WorkQueueStatusEnum = WorkQueueStatusEnum.Failed;
parms.ScheduledTime = Platform.Time;
parms.ExpirationTime = Platform.Time.AddDays(1);
OnWorkQueueEntryFailed(item, failureDescription);
}
else
{
Platform.Log(LogLevel.Error,
"Resetting {0} WorkQueue entry ({1}) to Pending, current retry count {2}. Failure Reason: {3}",
item.WorkQueueTypeEnum, item.GetKey(), item.FailureCount + 1, failureDescription);
parms.WorkQueueStatusEnum = WorkQueueStatusEnum.Pending;
parms.ScheduledTime = Platform.Time.AddMilliseconds(settings.WorkQueueQueryDelay);
parms.ExpirationTime =
Platform.Time.AddSeconds((prop.MaxFailureCount - item.FailureCount) *
prop.FailureDelaySeconds);
}
if (false == update.Execute(parms))
{
Platform.Log(LogLevel.Error, "Unable to update {0} WorkQueue GUID: {1}", item.WorkQueueTypeEnum,
item.GetKey().ToString());
}
else
{
updateContext.Commit();
break; // done
}
}
}
catch (Exception ex)
{
Platform.Log(LogLevel.Error, "Error occurred when calling FailQueueItem. Retry later. {0}", ex.Message);
_terminateEvent.WaitOne(2000, false);
if (_stop)
{
Platform.Log(LogLevel.Warn, "Service is stopping. Retry to fail the entry is terminated.");
break;
}
}
}
}
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);
}
}
}
