Пример #1
0
        /// <summary>
        /// Send a HL7 message
        /// </summary>
        /// <param name="message">Message to send</param>
        /// <returns>Reply message</returns>
        public string SendHL7Message(string message)
        {
            message = MLLP.CreateMLLPMessage(message);

            // Send the message
            StreamWriter sw = new StreamWriter(streamToUse);

            sw.Write(message);
            sw.Flush();

            // Read the reply
            StringBuilder sb = new StringBuilder();
            bool          messageComplete = false;

            while (!messageComplete)
            {
                int b = streamToUse.ReadByte();
                if (b != -1)
                {
                    sb.Append((char)b);
                }

                messageComplete = MLLP.ValidateMLLPMessage(sb);
            }
            MLLP.StripMLLPContainer(sb);

            return(sb.ToString());
        }
Пример #2
0
        public async Task M_EasyCLientSendsCommandToHL7InterfaceWaitAckAndResponse()
        {
            HL7InterfaceBase hl7Interface            = new HL7InterfaceBase();
            AutoResetEvent   ackReceived             = new AutoResetEvent(false);
            AutoResetEvent   commandResponseReceived = new AutoResetEvent(false);

            HL7Server serverSide = new HL7Server();

            Assert.IsTrue(serverSide.Setup("127.0.0.1", 50060));

            Assert.IsTrue(hl7Interface.Initialize(serverSide, new HL7ProtocolBase(new HL7ProtocolConfig())));

            Assert.That(hl7Interface.Start());

            hl7Interface.NewRequestReceived += (s, e) =>
            {
                string response = MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode());

                byte[] dataToSend = Encoding.ASCII.GetBytes(response);

                s.Send(dataToSend, 0, dataToSend.Length);
            };

            PrepareForSpecimenRequest request = new PrepareForSpecimenRequest();

            EasyClient client = new EasyClient();

            client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
            {
                if (packageInfo.Request.IsAcknowledge)
                {
                    Assert.That(packageInfo.Request is GeneralAcknowledgment);
                    Assert.That(HL7Parser.IsAckForRequest(request, packageInfo.Request));
                    ackReceived.Set();
                }
                else
                {
                    Assert.IsTrue(packageInfo.Request is PrepareForSpecimenResponse);
                    commandResponseReceived.Set();
                }
            });

            Assert.That(client.ConnectAsync(endPointA).Result);

            byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(request.Encode()));

            client.Send(bytesToSend);

            Assert.That(ackReceived.WaitOne());

            Assert.That(commandResponseReceived.WaitOne());

            await client.Close();

            serverSide.Stop();

            hl7Interface.Stop();
        }
Пример #3
0
        public async Task I_HL7InterfaceSendsMessageToHL7ServerWaitAckAndResponseTest()
        {
            HL7InterfaceBase hl7Interface    = new HL7InterfaceBase();
            HL7Server        server          = new HL7Server();
            AutoResetEvent   requestReceived = new AutoResetEvent(false);

            HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
            {
                IsAckRequired      = true,
                IsResponseRequired = true,
                AckTimeout         = 10000,
                ResponseTimeout    = 50000
            });

            HL7Server serverSide = new HL7Server();

            serverSide.Setup("127.0.0.1", 50060);

            server.Setup("127.0.0.1", 2012);
            server.Start();

            hl7Interface.Initialize(serverSide, protocol);

            hl7Interface.Start();

            server.NewRequestReceived += (e, s) =>
            {
                Assert.That(s.Request is PrepareForSpecimenRequest);
                requestReceived.Set();
                Thread.Sleep(500);
                byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode()));
                e.Send(bytesToSend, 0, bytesToSend.Length);
            };

            bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012));

            Assert.That(connected);

            HL7Request req = await hl7Interface.SendHL7MessageAsync(new PrepareForSpecimenRequest());

            Assert.IsNotNull(req);

            Assert.That(req.Acknowledgment is GeneralAcknowledgment);

            Assert.That(req.Acknowledgment.IsAckForRequest(req.Request));

            Assert.That(req.Acknowledgment.GetValue("MSA-1") == "AA");

            Assert.IsNotNull(req.Response);

            Assert.That(req.Response.IsResponseForRequest(req.Request));

            requestReceived.WaitOne();

            server.Stop();

            hl7Interface.Stop();
        }
Пример #4
0
        static void Send()
        {
            string content = @"MSH|^~\&|PEIS||EAI||20190320182547||ZMG^Z30|PEIS_3468011|P|2.4|||AL|AL|CHN  PID|1901090088|0000558984|0000558984^^^^IDCard~431002198702161010^^^^IdentifyNO||张洵||19870216|M||||||||||||||||||||||||||||||  PV1|1|T|^^^2400^健康管理中心|||||||||||||0|001921^李东霞|01|1901090088|||||||||0||||||||||||||||20190320182547|||||||0  ORC|NW|T1484237^^1901090088^o|T190109008800095159|1901090088|1||||20190320182547|001921||001921^李东霞|||20190320182547||2400^健康管理中心  OBR|4|||F00000095159^一般健康体检^WZ|||||||||||||||||||45|  ZDS||||F00000017022|||||||||||||||||||||||1||||||||||||||||||1||  ";

            content = MLLP.CreateMLLPMessage(content);

            var buffer = Encoding.UTF8.GetBytes(content);

            var temp = socketClient.Send(buffer);

            Console.WriteLine(temp);
            Console.WriteLine("发送成功");
        }
Пример #5
0
        public async Task SendMessageAsync(string message)
        {
            message = MLLP.CreateMLLPMessage(message);

            var buffer = Encoding.ASCII.GetBytes(message);

            await _networkStream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);

            await _networkStream.FlushAsync().ConfigureAwait(false);

            var responseBuffer = new byte[4096];
            int responseLength = await _networkStream.ReadAsync(responseBuffer, 0, responseBuffer.Length).ConfigureAwait(false);
        }
Пример #6
0
        public async Task L_EasyClientSendsCommandToHL7InterfaceAndWaitAck()
        {
            HL7InterfaceBase hl7Interface            = new HL7InterfaceBase();
            AutoResetEvent   ackReceived             = new AutoResetEvent(false);
            AutoResetEvent   commandResponseReceived = new AutoResetEvent(false);

            HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig()
            {
                IsAckRequired      = true,
                IsResponseRequired = true
            });

            HL7Server serverSide = new HL7Server();

            Assert.IsTrue(serverSide.Setup("127.0.0.1", 50060));

            Assert.IsTrue(hl7Interface.Initialize(serverSide, protocol));

            Assert.That(hl7Interface.Start());

            PrepareForSpecimenRequest request = new PrepareForSpecimenRequest();

            EasyClient client = new EasyClient();

            client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
            {
                if (packageInfo.Request.IsAcknowledge)
                {
                    Assert.That(packageInfo.Request is GeneralAcknowledgment);
                    Assert.That(HL7Parser.IsAckForRequest(request, packageInfo.Request));
                    ackReceived.Set();
                }
                else
                {
                    Assert.Fail();
                }
            });

            Assert.That(client.ConnectAsync(endPointA).Result);

            byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(request.Encode()));
            client.Send(bytesToSend);

            Assert.That(ackReceived.WaitOne(timeout));

            await client.Close();

            hl7Interface.Stop();
        }
Пример #7
0
        private bool SendAndWaitForAck(HL7Request hl7Request, ref int ackRetries)
        {
            m_HL7Server.Logger.Info($"Sending {hl7Request.Request.ControlID}");
            GlobalWatch.Restart();

            m_EasyClient.Send(Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(hl7Request.Request.Encode())));


            m_HL7Server.Logger.Info($"Sent {hl7Request.Request.ControlID}");

            string logMessage = string.Empty;

            logMessage = $"{hl7Request.Request.MessageID} sent (Ack RETRY) [{m_HL7Protocol.Config.MaxAckRetriesNumber}, {ackRetries}]";

            if (!Protocol.Config.IsAckRequired)
            {
                return(true);
            }

            if (!m_OutgoingRequests.Contains(hl7Request))
            {
                throw new OperationCanceledException("");
            }


            if (hl7Request.RequestCancellationToken.Token.IsCancellationRequested)
            {
                throw new OperationCanceledException(hl7Request.RequestCancellationToken.Token);
            }

            hl7Request.RequestCancellationToken.Token.ThrowIfCancellationRequested();

            m_HL7Server.Logger.Info($"Waiting for ack {hl7Request.Request.ControlID}");
            if (!hl7Request.AckReceivedEvent.Wait(Protocol.Config.AckTimeout, hl7Request.RequestCancellationToken.Token))
            {
                m_HL7Server.Logger.Info($"Ack received: {hl7Request.Request.ControlID}");
                if (ackRetries-- > 0)
                {
                    return(false);
                }
                else
                {
                    throw new HL7InterfaceException($"The message was not acknowledged after a total number of {m_HL7Protocol.Config.MaxAckRetriesNumber} retries");
                }
            }
            return(true);
        }
Пример #8
0
        public async Task E_EasyClientSendsHL7MessageToHL7InterfaceAndReceivesAck()
        {
            HL7InterfaceBase hl7Interface = new HL7InterfaceBase();

            AutoResetEvent newRequestReceived = new AutoResetEvent(false);

            Assert.IsTrue(hl7Interface.Initialize());

            Assert.IsTrue(hl7Interface.Start());

            PrepareForSpecimenRequest equipmentCommandRequest = new PrepareForSpecimenRequest();

            hl7Interface.HL7Server.NewRequestReceived += (hl7Session, hl7Request) =>
            {
                Assert.That(hl7Request is HL7Request);

                Assert.IsTrue(hl7Request.Request is PrepareForSpecimenRequest);

                Assert.That(hl7Session.Connected);
            };

            EasyClient client = new EasyClient();

            var tcs = new TaskCompletionSource <IHL7Message>();

            client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
            {
                tcs.SetResult(packageInfo.Request);
            });

            Assert.That(await client.ConnectAsync(endPointA));

            byte[] data = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(equipmentCommandRequest.Encode()));

            client.Send(data);

            var result = await tcs.Task;

            Assert.IsTrue(result.IsAcknowledge);

            Assert.IsTrue(HL7Parser.IsAckForRequest(equipmentCommandRequest, result));

            await client.Close();

            hl7Interface.Stop();
        }
        /// <summary>
        /// Send a HL7 message
        /// </summary>
        /// <param name="message">Message to send</param>
        /// <returns>Reply message</returns>
        public string SendHL7Message(string message)
        {
            message = MLLP.CreateMLLPMessage(message);

            // Send the message
            StreamWriter sw = new StreamWriter(streamToUse);

            sw.Write(message);
            sw.Flush();

            var stopwatch = new Stopwatch();

            if (ReceiveTimeoutInSeconds > 0)
            {
                stopwatch.Start();
            }

            // Read the reply
            StringBuilder sb = new StringBuilder();
            bool          messageComplete = false;

            while (!messageComplete)
            {
                int b = streamToUse.ReadByte();
                if (b != -1)
                {
                    sb.Append((char)b);
                }

                messageComplete = MLLP.ValidateMLLPMessage(sb);

                if (ReceiveTimeoutInSeconds > 0)
                {
                    if (stopwatch.ElapsedMilliseconds / 1000 > ReceiveTimeoutInSeconds)
                    {
                        messageComplete = true;
                        stopwatch.Stop();
                        return(string.Format("Timed out waiting for response after {0} seconds", ReceiveTimeoutInSeconds));
                    }
                }
            }
            MLLP.StripMLLPContainer(sb);

            return(sb.ToString());
        }
Пример #10
0
        public async Task F_HL7InterfaceReceivesHL7MessageSendsAResponseToEasyClient()
        {
            HL7InterfaceBase hl7Interface = new HL7InterfaceBase();

            AutoResetEvent newRequestReceived = new AutoResetEvent(false);

            Assert.IsTrue(hl7Interface.Initialize());

            Assert.IsTrue(hl7Interface.Start());

            PrepareForSpecimenRequest equipmentCommandRequest = new PrepareForSpecimenRequest();

            hl7Interface.HL7Server.NewSessionConnected += (hl7Session) =>
            {
                Assert.That(hl7Session.Connected);

                string response = MLLP.CreateMLLPMessage((new PrepareForSpecimenResponse()).Encode());

                byte[] dataToSend = Encoding.ASCII.GetBytes(response);

                hl7Session.Send(dataToSend, 0, dataToSend.Length);
            };

            EasyClient client = new EasyClient();

            var tcs = new TaskCompletionSource <IHL7Message>();

            client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
            {
                tcs.SetResult(packageInfo.Request);
            });

            Assert.That(await client.ConnectAsync(endPointA));

            var result = await tcs.Task;

            Assert.IsTrue(result is PrepareForSpecimenResponse);

            await client.Close();

            hl7Interface.Stop();
        }
Пример #11
0
        public async Task J_EasyClientSendsCommandToHL7ServerAndWaitAck()
        {
            AutoResetEvent ackReceived = new AutoResetEvent(false);

            HL7Server hl7Server = new HL7Server();

            hl7Server.Setup("127.0.0.1", 50060);

            hl7Server.Start();

            PrepareForSpecimenRequest request = new PrepareForSpecimenRequest();

            EasyClient client = new EasyClient();

            client.Initialize(new ReceiverFilter(new HL7ProtocolBase()), (packageInfo) =>
            {
                if (packageInfo.Request.IsAcknowledge)
                {
                    Assert.That(packageInfo.Request is GeneralAcknowledgment);
                    Assert.That(HL7Parser.IsAckForRequest(request, packageInfo.Request));
                    ackReceived.Set();
                }
                else
                {
                    Assert.Fail();
                }
            });

            Assert.That(client.ConnectAsync(endPointA).Result);

            Assert.That(client.IsConnected);

            byte[] bytesToSend = Encoding.ASCII.GetBytes(MLLP.CreateMLLPMessage(request.Encode()));
            client.Send(bytesToSend);

            Assert.That(ackReceived.WaitOne());

            await client.Close();

            hl7Server.Stop();
        }
Пример #12
0
        /// <summary>
        /// Send a HL7 message
        /// </summary>
        /// <param name="message">Message to send</param>
        /// <param name="timeout">Read timeout, throws exception when receiving no data until timeout</param>
        /// <returns>Reply message</returns>
        /// <exception cref="TimeoutException">throws exception on read timeout</exception>
        public string SendHL7Message(string message, double timeout = 30000)
        {
            message = MLLP.CreateMLLPMessage(message);

            // Send the message
            StreamWriter sw = new StreamWriter(streamToUse, encodingForStream);

            sw.Write(message);
            sw.Flush();

            // Read the reply
            StringBuilder sb = new StringBuilder();
            bool          messageComplete  = false;
            DateTime      startReadingTime = DateTime.Now;

            while (!messageComplete)
            {
                int b = streamToUse.ReadByte();
                if (b != -1)
                {
                    sb.Append((char)b);
                }

                messageComplete = MLLP.ValidateMLLPMessage(sb);

                if (b > 0) // reset start reading time for timout check
                {
                    startReadingTime = DateTime.Now;
                }

                if (!messageComplete && DateTime.Now.Subtract(startReadingTime).TotalMilliseconds > timeout)
                {
                    throw new TimeoutException($"Reading the HL7 reply timed out after {timeout} milliseconds.");
                }
            }
            MLLP.StripMLLPContainer(sb);

            return(sb.ToString());
        }
Пример #13
0
        /// <summary>
        /// Send
        /// </summary>
        /// <param name="message"></param>
        public override void Send(string message)
        {
            message = MLLP.CreateMLLPMessage(message);

            base.Send(message);
        }