void IDicomServerHandler.OnReceiveReleaseRequest(DicomServer server, ServerAssociationParameters association) { LogAdapter.Logger.InfoWithFormat("Received association release request from {0} to {1}.", association.CallingAE, association.CalledAE); if (_complete != null) { _complete(_context, association, _instances); } OnAssociationRelease(server, association); Cleanup(); }
void IDicomServerHandler.OnReceiveAbort(DicomServer server, ServerAssociationParameters association, DicomAbortSource source, DicomAbortReason reason) { LogAdapter.Logger.ErrorWithFormat("Received association abort from {0} to {1}", association.CallingAE, association.CalledAE); if (_complete != null) { _complete(_context, association, _instances); } OnAssociationAbort(server, association); Cleanup(); }
private static void RemoveAllAssociationMppsFromCache(ServerAssociationParameters association) { ListDictionary mppsAssociationList; if (_mppsCache.TryGetValue(association.GetHashCode(), out mppsAssociationList)) { mppsAssociationList.Clear(); _mppsCache.Remove(association.GetHashCode()); } Logger.LogInfo("Remove All Association cached mppsiod."); }
private static void AddPresentationContexts(ServerAssociationParameters assoc) { byte pcid = assoc.AddPresentationContext(SopClass.VerificationSopClass); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); pcid = assoc.AddPresentationContext(SopClass.ModalityWorklistInformationModelFind); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); }
/// <summary> /// Image transfer syntaxes /// </summary> /// <param name="pcid"></param> /// <param name="assoc"></param> public static void SetImageTransferSyntaxes(byte pcid, ServerAssociationParameters assoc) { assoc.AddTransferSyntax(pcid, TransferSyntax.JpegLosslessNonHierarchicalFirstOrderPredictionProcess14SelectionValue1); assoc.AddTransferSyntax(pcid, TransferSyntax.RleLossless); assoc.AddTransferSyntax(pcid, TransferSyntax.Jpeg2000ImageCompression); assoc.AddTransferSyntax(pcid, TransferSyntax.Jpeg2000ImageCompressionLosslessOnly); assoc.AddTransferSyntax(pcid, TransferSyntax.JpegBaselineProcess1); assoc.AddTransferSyntax(pcid, TransferSyntax.JpegExtendedProcess24); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); }
public void StorageScuMoveOriginatorTest() { int port = 2112; _serverHandlerList.Clear(); /* Setup the Server */ var serverParameters = new ServerAssociationParameters("AssocTestServer", new IPEndPoint(IPAddress.Any, port)); byte pcid = serverParameters.AddPresentationContext(SopClass.MrImageStorage); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrBigEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); _serverType = TestTypes.Receive; DicomServer.StartListening(serverParameters, ServerHandlerCreator); string moveOriginatorAe = "ORIGINATOR"; ushort moveOriginatorId = 999; StorageScu scu = SetupScu(moveOriginatorAe, moveOriginatorId); IList <DicomAttributeCollection> list = SetupMRSeries(4, 2, DicomUid.GenerateUid().UID); foreach (DicomAttributeCollection collection in list) { var file = new DicomFile("test", new DicomAttributeCollection(), collection) { TransferSyntax = TransferSyntax.ExplicitVrLittleEndian, MediaStorageSopClassUid = SopClass.MrImageStorage.Uid, MediaStorageSopInstanceUid = collection[DicomTags.SopInstanceUid].ToString() }; scu.AddStorageInstance(new StorageInstance(file)); } scu.Send(); scu.Join(); Assert.AreEqual(scu.Status, ScuOperationStatus.NotRunning); var handler = CollectionUtils.FirstElement(_serverHandlerList); var serverHandler = handler as ServerHandler; Assert.NotNull(serverHandler); foreach (var message in serverHandler.MessagesReceived) { Assert.AreEqual(message.MoveOriginatorApplicationEntityTitle, moveOriginatorAe); Assert.AreEqual(message.MoveOriginatorMessageId, moveOriginatorId); } // StopListening DicomServer.StopListening(serverParameters); }
private static void AddPresentationContexts(ServerAssociationParameters assoc) { byte pcid = assoc.AddPresentationContext(SopClass.VerificationSopClass); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); pcid = assoc.AddPresentationContext(SopClass.ModalityPerformedProcedureStepSopClass); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); }
/// <summary> /// Constructor. /// </summary> /// <remarks> /// The constructor creates a dictionary of each presentation context negotiated for the /// association, and the plugin that will handle it. This is used later when incoming request /// messages are processed. /// </remarks> /// <param name="server">The server.</param> /// <param name="parameters">Association parameters for the negotiated association.</param> /// <param name="userParms">User parameters to be passed to the plugins called by the class.</param> /// <param name="verifier">Delegate to call to verify an association before its accepted.</param> /// <param name="complete">Delegate to call when the association is closed/complete. Can be null.</param> public DicomScpHandler(DicomServer server, ServerAssociationParameters parameters, TContext userParms, DicomScp <TContext> .AssociationVerifyCallback verifier, DicomScp <TContext> .AssociationComplete complete) { _context = userParms; _verifier = verifier; _complete = complete; DicomScpExtensionPoint <TContext> ep = new DicomScpExtensionPoint <TContext>(); object[] scps = ep.CreateExtensions(); // First set the user parms for each of the extensions before we do anything with them. foreach (object obj in scps) { IDicomScp <TContext> scp = obj as IDicomScp <TContext>; scp.SetContext(_context); } // Now, create a dictionary with the extension to be used for each presentation context. foreach (byte pcid in parameters.GetPresentationContextIDs()) { if (parameters.GetPresentationContextResult(pcid) == DicomPresContextResult.Accept) { SopClass acceptedSop = SopClass.GetSopClass(parameters.GetAbstractSyntax(pcid).UID); TransferSyntax acceptedSyntax = parameters.GetAcceptedTransferSyntax(pcid); foreach (object obj in scps) { IDicomScp <TContext> scp = obj as IDicomScp <TContext>; IList <SupportedSop> sops = scp.GetSupportedSopClasses(); foreach (SupportedSop sop in sops) { if (sop.SopClass.Equals(acceptedSop)) { if (sop.SyntaxList.Contains(acceptedSyntax)) { if (!_extensionList.ContainsKey(pcid)) { _extensionList.Add(pcid, scp); break; } else { Platform.Log(LogLevel.Error, "SOP Class {0} supported by more than one extension", sop.SopClass.Name); } } } } } } } _statsRecorder = new AssociationStatisticsRecorder(server); }
private static void RemoveMppsEntityFromCache(ServerAssociationParameters association, string key) { ListDictionary mppsAssociationList; if (_mppsCache.TryGetValue(association.GetHashCode(), out mppsAssociationList)) { if (mppsAssociationList.Contains(key)) { mppsAssociationList.Remove(key); } } }
public bool CompleteStream(DicomServer server, ServerAssociationParameters assoc, byte presentationId, DicomMessage message) { DicomProcessingResult result; try { if (_fileStream != null) { _fileStream.Flush(true); _fileStream.Close(); _fileStream.Dispose(); _fileStream = null; } ISopInstanceImporter importer = IoC.Get <ISopInstanceImporter>(); importer.Context = _importContext; result = importer.ImportFile(message, _sourceFilename); if (result.Successful) { if (!String.IsNullOrEmpty(result.AccessionNumber)) { Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (A#:{3} StudyUid:{4})", result.SopInstanceUid, assoc.CallingAE, assoc.CalledAE, result.AccessionNumber, result.StudyInstanceUid); } else { Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (StudyUid:{3})", result.SopInstanceUid, assoc.CallingAE, assoc.CalledAE, result.StudyInstanceUid); } } } catch (Exception e) { result = new DicomProcessingResult { DicomStatus = DicomStatuses.ProcessingFailure, ErrorMessage = e.Message }; } if (!result.Successful) { Platform.Log(LogLevel.Warn, "Failure importing sop: {0}", result.ErrorMessage); } CleanupDirectory(); server.SendCStoreResponse(presentationId, message.MessageId, message.AffectedSopInstanceUid, result.DicomStatus); return(true); }
public override bool OnReceiveRequest(DicomServer server, ServerAssociationParameters association, byte presentationId, DicomMessage message) { try { SopInstanceImporterContext context = new SopInstanceImporterContext( String.Format("{0}_{1}", association.CallingAE, association.TimeStamp.ToString("yyyyMMddhhmmss")), association.CallingAE, Partition.AeTitle); DicomProcessingResult result = new DicomProcessingResult(); ISopInstanceImporter importer = IoC.Get <ISopInstanceImporter>(); if (importer != null) { importer.Context = context; result = importer.Import(message); } if (result.Successful) { if (!String.IsNullOrEmpty(result.AccessionNumber)) { Log.Logger.Info("Received SOP Instance {0} from {1} to {2} (A#:{3} StudyUid:{4})", result.SopInstanceUid, association.CallingAE, association.CalledAE, result.AccessionNumber, result.StudyInstanceUid); } else { Log.Logger.Info("Received SOP Instance {0} from {1} to {2} (StudyUid:{3})", result.SopInstanceUid, association.CallingAE, association.CalledAE, result.StudyInstanceUid); } } else { Log.Logger.Warn("Failure importing sop: {0}", result.ErrorMessage); } server.SendCStoreResponse(presentationId, message.MessageId, message.AffectedSopInstanceUid, result.DicomStatus); return(true); } catch (DicomDataException ex) { Log.Logger.Error(ex, "Error when import {0}", message.AffectedSopInstanceUid); return(false); // caller will abort the association } catch (Exception ex) { Log.Logger.Error(ex, "Error when import {0}", message.AffectedSopInstanceUid); return(false); // caller will abort the association } }
void IDicomServerHandler.OnReceiveRequestMessage(DicomServer server, ServerAssociationParameters association, byte presentationID, DicomMessage message) { _sessionDebug.SetAssociationDumpString(association); _sessionDebug._request = message.Dump(); #region Cancel request if (message.CommandField == DicomCommandField.CCancelRequest) { Logger.LogInfo("Received CANCEL-RQ message from {0}.", association.CallingAE); _cancelReceived = true; return; } #endregion #region CEcho request if (message.CommandField == DicomCommandField.CEchoRequest) { server.SendCEchoResponse(presentationID, message.MessageId, DicomStatuses.Success); Logger.LogInfo("Received ECHO-RQ message from {0}.", association.CallingAE); return; } #endregion #region MWL C-FIND request if (message.CommandField == DicomCommandField.CFindRequest) { Logger.LogInfo("Message Dumped :\n" + message.Dump("", DicomDumpOptions.KeepGroupLengthElements)); String level = message.DataSet[DicomTags.QueryRetrieveLevel].GetString(0, string.Empty); _cancelReceived = false; if (message.AffectedSopClassUid.Equals(SopClass.ModalityWorklistInformationModelFindUid)) { OnReceiveMWLQuery(server, presentationID, message); } else { // Not supported message type, send a failure status. server.SendCFindResponse(presentationID, message.MessageId, new DicomMessage(), DicomStatuses.QueryRetrieveIdentifierDoesNotMatchSOPClass); } return; } #endregion //ignore all unsupported request server.SendAssociateAbort(DicomAbortSource.ServiceProvider, DicomAbortReason.UnexpectedPDU); Logger.LogInfo("Unexpected Command. Send Associate Abort message from server to {0}.", association.CallingAE); return; }
public StorageFilestreamHandler(DicomScpContext context, ServerAssociationParameters assoc) { _context = context; //_remoteDevice = remoteDevice; _importContext = new SopInstanceImporterContext( String.Format("{0}_{1}", assoc.CallingAE, assoc.TimeStamp.ToString("yyyyMMddhhmmss")), assoc.CallingAE, assoc.CalledAE); //if (_remoteDevice != null && _remoteDevice.DeviceTypeEnum.Equals(DeviceTypeEnum.PrimaryPacs)) //{ // _importContext.DuplicateProcessing = DuplicateProcessingEnum.OverwriteSopAndUpdateDatabase; //} }
private static bool IsMppsEntitycached(ServerAssociationParameters association, string key) { ListDictionary mppsAssociationList; if (_mppsCache.TryGetValue(association.GetHashCode(), out mppsAssociationList)) { return(false); } else { return(mppsAssociationList.Contains(key)); } }
/// <summary> /// Constructor. /// </summary> /// <remarks> /// The constructor creates a dictionary of each presentation context negotiated for the /// association, and the plugin that will handle it. This is used later when incoming request /// messages are processed. /// </remarks> /// <param name="server">The server.</param> /// <param name="parameters">Association parameters for the negotiated association.</param> /// <param name="userParms">User parameters to be passed to the plugins called by the class.</param> /// <param name="verifier">Delegate to call to verify an association before its accepted.</param> /// <param name="complete">Delegate to call when the association is closed/complete. Can be null.</param> public DicomScpHandler(DicomServer server, ServerAssociationParameters parameters, TContext userParms, DicomScp <TContext> .AssociationVerifyCallback verifier, DicomScp <TContext> .AssociationComplete complete) { _context = userParms; _verifier = verifier; _complete = complete; List <IDicomScp <TContext> > scps = Platform.Instance.CompositionContainer.GetExportedValues <IDicomScp <TContext> >().Select(scp => scp). ToList(); // First set the user parms for each of the extensions before we do anything with them. foreach (object obj in scps) { IDicomScp <TContext> scp = obj as IDicomScp <TContext>; scp.SetContext(_context); } // Now, create a dictionary with the extension to be used for each presentation context. foreach (byte pcid in parameters.GetPresentationContextIDs()) { if (parameters.GetPresentationContextResult(pcid) == DicomPresContextResult.Accept) { SopClass acceptedSop = SopClass.GetSopClass(parameters.GetAbstractSyntax(pcid).UID); TransferSyntax acceptedSyntax = parameters.GetAcceptedTransferSyntax(pcid); foreach (object obj in scps) { IDicomScp <TContext> scp = obj as IDicomScp <TContext>; IList <SupportedSop> sops = scp.GetSupportedSopClasses(); foreach (SupportedSop sop in sops) { if (sop.SopClass.Equals(acceptedSop)) { if (sop.SyntaxList.Contains(acceptedSyntax)) { if (!_extensionList.ContainsKey(pcid)) { _extensionList.Add(pcid, scp); break; } else { LogAdapter.Logger.ErrorWithFormat("SOP Class {0} supported by more than one extension", sop.SopClass.Name); } } } } } } } }
public void RejectTests() { int port = 2112; /* Setup the Server */ ServerAssociationParameters serverParameters = new ServerAssociationParameters("AssocTestServer", new IPEndPoint(IPAddress.Any, port)); byte pcid = serverParameters.AddPresentationContext(SopClass.MrImageStorage); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrBigEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); _serverType = TestTypes.AssociationReject; DicomServer.StartListening(serverParameters, ServerHandlerCreator); /* Setup the client */ ClientAssociationParameters clientParameters = new ClientAssociationParameters("AssocTestClient", "AssocTestServer", new System.Net.IPEndPoint(IPAddress.Loopback, port)); pcid = clientParameters.AddPresentationContext(SopClass.CtImageStorage); clientParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); clientParameters.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); /* Open the association */ ClientHandler handler = new ClientHandler(this, TestTypes.AssociationReject); DicomClient client = DicomClient.Connect(clientParameters, handler); handler._threadStop.WaitOne(); client.Dispose(); _serverType = TestTypes.AssociationReject; /* Setup the client */ clientParameters = new ClientAssociationParameters("AssocTestClient", "AssocTestServer", new System.Net.IPEndPoint(IPAddress.Loopback, port)); pcid = clientParameters.AddPresentationContext(SopClass.MrImageStorage); clientParameters.AddTransferSyntax(pcid, TransferSyntax.Jpeg2000ImageCompressionLosslessOnly); /* Open the association */ ClientHandler clientHandler = new ClientHandler(this, TestTypes.AssociationReject); client = DicomClient.Connect(clientParameters, clientHandler); handler._threadStop.WaitOne(); client.Dispose(); DicomServer.StopListening(serverParameters); }
public override bool OnReceiveRequest(DicomServer server, ServerAssociationParameters association, byte presentationId, DicomMessage message) { try { var context = new SopInstanceImporterContext( String.Format("{0}_{1}", association.CallingAE, association.TimeStamp.ToString("yyyyMMddhhmmss")), association.CallingAE, association.CalledAE); if (Device != null && Device.DeviceTypeEnum.Equals(DeviceTypeEnum.PrimaryPacs)) { context.DuplicateProcessing = DuplicateProcessingEnum.OverwriteSopAndUpdateDatabase; } var importer = new SopInstanceImporter(context); DicomProcessingResult result = importer.Import(message); if (result.Successful) { if (!String.IsNullOrEmpty(result.AccessionNumber)) { Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (A#:{3} StudyUid:{4})", result.SopInstanceUid, association.CallingAE, association.CalledAE, result.AccessionNumber, result.StudyInstanceUid); } else { Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (StudyUid:{3})", result.SopInstanceUid, association.CallingAE, association.CalledAE, result.StudyInstanceUid); } } else { Platform.Log(LogLevel.Warn, "Failure importing sop: {0}", result.ErrorMessage); } server.SendCStoreResponse(presentationId, message.MessageId, message.AffectedSopInstanceUid, result.DicomStatus); return(true); } catch (DicomDataException ex) { Platform.Log(LogLevel.Error, ex); return(false); // caller will abort the association } catch (Exception ex) { Platform.Log(LogLevel.Error, ex); return(false); // caller will abort the association } }
void IDicomServerHandler.OnReceiveAssociateRequest(DicomServer server, ServerAssociationParameters association) { if (_verifier != null) { DicomRejectResult result; DicomRejectReason reason; bool verified = _verifier(_context, association, out result, out reason); if (verified == false) { server.SendAssociateReject(result, DicomRejectSource.ServiceUser, reason); LogAdapter.Logger.Info("Association rejected from {0} to {1}", association.CallingAE, association.CalledAE); return; } } // Let the extensions have its say on whether a presentation context is really acceptable. // bool atLeastOneAccepted = false; foreach (byte pcid in association.GetPresentationContextIDs()) { if (association.GetPresentationContextResult(pcid) == DicomPresContextResult.Accept) { IDicomScp <TContext> scp = _extensionList[pcid]; DicomPresContextResult res = scp.VerifyAssociation(association, pcid); if (res != DicomPresContextResult.Accept) { association.GetPresentationContext(pcid).ClearTransfers(); association.SetPresentationContextResult(pcid, res); } else { atLeastOneAccepted = true; } } } if (!atLeastOneAccepted) { LogAdapter.Logger.Info("None of the proposed presentation context is accepted. Rejecting association from {0} to {1}", association.CallingAE, association.CalledAE); server.SendAssociateReject(DicomRejectResult.Permanent, DicomRejectSource.ServiceUser, DicomRejectReason.NoReasonGiven); return; } server.SendAssociateAccept(association); // Optimization to speed query performance Task.Factory.StartNew(() => LogAdapter.Logger.Info("Received association:\r\n{0}", association.ToString())); }
public static void AddPresentationContexts(ServerAssociationParameters assoc, Configuration.SOPClassSet sops) { byte pcid = assoc.AddPresentationContext(SopClass.VerificationSopClass); assoc.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); assoc.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); FindMatchingSOPS(sops).ForEach( s => { pcid = assoc.AddPresentationContext(s); SetImageTransferSyntaxes(pcid, assoc); log.Info(string.Format("Allow SOP class {0}", s.Name)); } ); }
public static void StartListening(string aeTitle, int port) { if (_started) { return; } _staticAssocParameters = new ServerAssociationParameters(aeTitle, new IPEndPoint(IPAddress.Any, port)); AddPresentationContexts(_staticAssocParameters); DicomServer.StartListening(_staticAssocParameters, (server, assoc) => new StorageScp(server, assoc)); _started = true; }
public static void StartListening(string aeTitle, IPAddress ip, int port) { if (_running) { return; } _param = new ServerAssociationParameters(aeTitle, new IPEndPoint(ip, port)); AddPresentationContexts(_param); DicomServer.StartListening(_param, (server, assoc) => new dcmServer(server, assoc)); _running = true; }
public void OnReceiveAssociateRequest(DicomServer server, ServerAssociationParameters association) { if (_delayAssociationAccept.Checked) { Thread.Sleep(TimeSpan.FromSeconds(35)); } if (_rejectAssociation.Checked) { server.SendAssociateReject(DicomRejectResult.Permanent, DicomRejectSource.ServiceUser, DicomRejectReason.CallingAENotRecognized); } else { server.SendAssociateAccept(association); } }
private static ModalityPerformedProcedureStepIod GetCachedMppsIod(ServerAssociationParameters association, string cacheKeyId) { ListDictionary mppsAssociationList; if (_mppsCache.TryGetValue(association.GetHashCode(), out mppsAssociationList)) { if (mppsAssociationList.Contains(cacheKeyId)) { return(mppsAssociationList[cacheKeyId] as ModalityPerformedProcedureStepIod); } else { return(null); } } return(null); }
public void OnReceiveRequestMessage(DicomServer server, ServerAssociationParameters association, byte presentationID, DicomMessage message) { if (_type == TestTypes.SendMR) { var testSet = new DicomAttributeCollection(); _test.SetupMR(testSet); bool same = testSet.Equals(message.DataSet); string studyId = message.DataSet[DicomTags.StudyId].GetString(0, ""); Assert.AreEqual(studyId, "1933"); DicomUid sopInstanceUid; bool ok = message.DataSet[DicomTags.SopInstanceUid].TryGetUid(0, out sopInstanceUid); if (!ok) { server.SendAssociateAbort(DicomAbortSource.ServiceUser, DicomAbortReason.NotSpecified); return; } server.SendCStoreResponse(presentationID, message.MessageId, sopInstanceUid.UID, DicomStatuses.Success); } else if (_type == TestTypes.Receive) { DicomUid sopInstanceUid; bool ok = message.DataSet[DicomTags.SopInstanceUid].TryGetUid(0, out sopInstanceUid); if (!ok) { server.SendAssociateAbort(DicomAbortSource.ServiceUser, DicomAbortReason.InvalidPDUParameter); return; } MessagesReceived.Add(message); server.SendCStoreResponse(presentationID, message.MessageId, sopInstanceUid.UID, DicomStatuses.Success); } else { Platform.Log(LogLevel.Error, "Unexpected test type mode"); server.SendAssociateAbort(DicomAbortSource.ServiceUser, DicomAbortReason.InvalidPDUParameter); } }
public void ScuAbortTest() { int port = 2112; /* Setup the Server */ var serverParameters = new ServerAssociationParameters("AssocTestServer", new IPEndPoint(IPAddress.Any, port)); byte pcid = serverParameters.AddPresentationContext(SopClass.MrImageStorage); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrLittleEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ExplicitVrBigEndian); serverParameters.AddTransferSyntax(pcid, TransferSyntax.ImplicitVrLittleEndian); _serverType = TestTypes.Receive; DicomServer.StartListening(serverParameters, ServerHandlerCreator); StorageScu scu = SetupScu(); IList <DicomAttributeCollection> list = SetupMRSeries(4, 2, DicomUid.GenerateUid().UID); foreach (DicomAttributeCollection collection in list) { var file = new DicomFile("test", new DicomAttributeCollection(), collection) { TransferSyntax = TransferSyntax.ExplicitVrLittleEndian, MediaStorageSopClassUid = SopClass.MrImageStorage.Uid, MediaStorageSopInstanceUid = collection[DicomTags.SopInstanceUid].ToString() }; scu.AddStorageInstance(new StorageInstance(file)); } scu.ImageStoreCompleted += delegate(object o, StorageInstance instance) { // Test abort scu.Abort(); }; scu.Send(); scu.Join(); Assert.AreEqual(scu.Status, ScuOperationStatus.NetworkError); // StopListening DicomServer.StopListening(serverParameters); }
public static void StartListening(string aeTitle, int port) { if (_started) { return; } _staticAssocParameters = new ServerAssociationParameters(aeTitle, new IPEndPoint(IPAddress.Any, port)); Platform.Log(LogLevel.Info, "MPPS Server Started"); AddPresentationContexts(_staticAssocParameters); DicomServer.StartListening(_staticAssocParameters, delegate(DicomServer server, ServerAssociationParameters assoc) { return(new MPPSScp(assoc)); }); _started = true; }
void IDicomServerHandler.OnReceiveRequestMessage(DicomServer server, ServerAssociationParameters association, byte presentationID, DicomMessage message) { IDicomScp <TContext> scp = _extensionList[presentationID]; bool ok = scp.OnReceiveRequest(server, association, presentationID, message); if (!ok) { Platform.Log(LogLevel.Error, "Unexpected error processing message of type {0}. Aborting association.", message.SopClass.Name); server.SendAssociateAbort(DicomAbortSource.ServiceProvider, DicomAbortReason.NotSpecified); } else if (_complete != null) { // Only save C-STORE-RQ messages if (message.CommandField == DicomCommandField.CStoreRequest) { _instances.Add(new StorageInstance(message)); } } }
/// <summary> /// Store an image into the cache. /// </summary> /// <param name="configuration"></param> /// <param name="association"></param> /// <param name="message"></param> /// <param name="syntax"></param> /// <param name="studyInstanceUid"></param> /// <param name="seriesInstanceUid"></param> /// <param name="sopInstanceUid"></param> /// <param name="patientName"></param> public static void AddToCache( ListenerConfigurationInstance configuration, ServerAssociationParameters association, DicomMessage message, TransferSyntax syntax, string studyInstanceUid, string seriesInstanceUid, string sopInstanceUid, string patientName ) { var path = CachePathFactory.CreatePath(configuration.Root, configuration.StorageStrategy, message); log.Info(string.Format("Cache destination path {0}", path)); if (File.Exists(path) && !configuration.StorageStrategy.File.Overwrite) { log.Info("Cache destination exists and storage strategy says don't overwrite!"); return; } Directory.CreateDirectory(Path.GetDirectoryName(path)); var dicomFile = new DicomFile(message, path.ToString()) { TransferSyntaxUid = syntax.UidString, MediaStorageSopInstanceUid = sopInstanceUid, ImplementationClassUid = DicomImplementation.ClassUID.UID, ImplementationVersionName = DicomImplementation.Version, SourceApplicationEntityTitle = association.CallingAE, MediaStorageSopClassUid = message.SopClass.Uid }; // Retrieve a modalityRule action and apply it. ModalityRuleFactory.Create(message, configuration).Process(dicomFile); log.Info("Saving file"); dicomFile.Save(DicomWriteOptions.None); }
public override bool OnReceiveRequest(DicomServer server, ServerAssociationParameters association, byte presentationID, DicomMessage message) { try { server.SendCStoreResponse(presentationID, message.MessageId, message.AffectedSopInstanceUid, DicomStatuses.Success); } catch (DicomDataException ex) { LogAdapter.Logger.TraceException(ex); return(false); // caller will abort the association } catch (Exception ex) { LogAdapter.Logger.TraceException(ex); return(false); // caller will abort the association } return(true); }
protected void LoadImportContext(ServerAssociationParameters association) { _importContext = new DicomReceiveImportContext(association.CallingAE, GetRemoteHostName(association), StudyStore.GetConfiguration(), EventSource.CurrentProcess); // Publish new WorkItems as they're added to the context lock (_importContext.StudyWorkItemsSyncLock) { _importContext.StudyWorkItems.ItemAdded += delegate(object sender, DictionaryEventArgs <string, WorkItem> args) { Platform.GetService( (IWorkItemActivityMonitorService service) => service.Publish(new WorkItemPublishRequest { Item = WorkItemDataHelper.FromWorkItem(args.Item) })); var auditedInstances = new AuditedInstances(); var request = args.Item.Request as DicomReceiveRequest; if (request != null) { auditedInstances.AddInstance(request.Patient.PatientId, request.Patient.PatientsName, request.Study.StudyInstanceUid); } AuditHelper.LogReceivedInstances( association.CallingAE, GetRemoteHostName(association), auditedInstances, EventSource.CurrentProcess, EventResult.Success, EventReceiptAction.ActionUnknown); }; _importContext.StudyWorkItems.ItemChanged += (sender, args) => Platform.GetService( (IWorkItemActivityMonitorService service) => service.Publish(new WorkItemPublishRequest { Item = WorkItemDataHelper.FromWorkItem(args.Item) })); } }