public virtual bool Initialize() { IBootstrap bootstrap = BootstrapFactory.CreateBootstrap(); if (!bootstrap.Initialize()) { return(false); } IWorkItem item = bootstrap.AppServers.FirstOrDefault(server => server.Name == Name); m_HL7Server = item as HL7Server; if (m_HL7Server == null) { return(false); } m_HL7Server.Logger.Debug("the Server side is initializing"); HL7SocketServiceConfig config = bootstrap.Config as HL7SocketServiceConfig; if (config == null && config.ProtocolConfig == null) { return(false); } m_HL7Protocol.Config = config.ProtocolConfig; return(Initialize(m_HL7Server, m_HL7Protocol)); }
public async Task O_HL7InterfaceSelfConnectShouldFail() { HL7InterfaceBase hl7InterfaceA = new HL7InterfaceBase(); HL7ProtocolBase protocolA = new HL7ProtocolBase(new HL7ProtocolConfig() { IsAckRequired = true, IsResponseRequired = false }); HL7Server serverA = new HL7Server(); Assert.IsTrue(serverA.Setup("127.0.0.1", 50060)); Assert.IsTrue(hl7InterfaceA.Initialize(serverA, protocolA)); Assert.That(hl7InterfaceA.Start()); hl7InterfaceA.NewSessionConnected += (e) => { }; Assert.IsFalse(await hl7InterfaceA.ConnectAsync(endPointA)); hl7InterfaceA.Stop(); }
private void StartUp() { Platform.Log(LogLevel.Info, "Starting application root {0}", this.GetType().FullName); var hostUri = new Uri(WebServicesSettings.Default.BaseUrl); _serviceMount = new ServiceMount(hostUri, WebServicesSettings.Default.ConfigurationClass) { EnablePerformanceLogging = WebServicesSettings.Default.EnablePerformanceLogging, MaxReceivedMessageSize = WebServicesSettings.Default.MaxReceivedMessageSize, SendExceptionDetailToClient = WebServicesSettings.Default.SendExceptionDetailToClient, CertificateSearchDirective = GetCertificateSearchDirective(WebServicesSettings.Default, hostUri) }; _serviceMount.AddServices(new CoreServiceExtensionPoint()); _serviceMount.AddServices(new ApplicationServiceExtensionPoint()); Platform.Log(LogLevel.Info, "Starting WCF services on {0}...", WebServicesSettings.Default.BaseUrl); _serviceMount.OpenServices(); Platform.Log(LogLevel.Info, "WCF Services started on {0}", WebServicesSettings.Default.BaseUrl); // kick NHibernate, rather than waiting for it to load on demand PersistentStoreRegistry.GetDefaultStore(); // Start the HL7 server _hl7server = new HL7Server(); _hl7server.start(); _isStarted = true; }
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(); }
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(); }
/// <summary> /// Create a new Instance of HL7Interface /// </summary> public HL7InterfaceBase() { m_OutgoingRequests = new BlockingCollection <HL7Request>(); m_EasyClient = new SuperSocket.ClientEngine.EasyClient(); m_HL7Protocol = new HL7ProtocolBase(); m_HL7Server = new HL7Server(); m_OutgoingRequests1 = new ConcurrentDictionary <string, HL7Request>(); m_AckReceivedLock = new object(); }
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(); }
static void Main(string[] args) { ServiceManager sm = new ServiceManager(); Console.WriteLine("Thorton's HL7 Server"); Console.WriteLine(); Console.Write("Loading services..."); sm.LoadServices(); Console.WriteLine(" [DONE]"); Console.WriteLine("Starting Server"); HL7Server server = new HL7Server(sm); server.StartListening(); }
public void Update() { if (!started) { LaunchManager launchManager = GameObject.FindGameObjectWithTag("LaunchManager").GetComponent <LaunchManager>(); LoggingManager log = launchManager.LoggingManager; if (log != null) { workerObject = new HL7Server(log, LocalIPAddress()); workerThread = new Thread(workerObject.DoWork); // Start the worker thread. workerThread.Start(); started = true; } } }
public async Task H_HL7InterfaceSendsMessageToHL7ServerWaitAck() { HL7InterfaceBase hl7Interface = new HL7InterfaceBase(); HL7Server server = new HL7Server(); AutoResetEvent requestReceived = new AutoResetEvent(false); HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig() { IsAckRequired = true, IsResponseRequired = false }); 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(); }; 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(HL7Parser.IsAckForRequest(req.Request, req.Acknowledgment)); requestReceived.WaitOne(); server.Stop(); hl7Interface.Stop(); }
public async Task G_HL7InterfaceSendsMessageToHL7ServerNoAckNoResponse() { HL7InterfaceBase hl7Interface = new HL7InterfaceBase(); HL7Server server = new HL7Server(); AutoResetEvent requestReceived = new AutoResetEvent(false); HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig() { IsAckRequired = false, IsResponseRequired = false }); server.Setup("127.0.0.1", 50050); server.Start(); HL7Server serverSide = new HL7Server(); serverSide.Setup("127.0.0.1", 50060); hl7Interface.Initialize(serverSide, protocol); hl7Interface.Start(); server.NewRequestReceived += (e, s) => { Assert.That(s.Request is PrepareForSpecimenRequest); requestReceived.Set(); }; bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50050)); Assert.That(connected); await hl7Interface.SendHL7MessageAsync(new PrepareForSpecimenRequest()); requestReceived.WaitOne(); server.Stop(); hl7Interface.Stop(); }
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(); }
public async Task B_ConnectHL7InterfaceToAppServer() { HL7InterfaceBase hl7Interface = new HL7InterfaceBase(); HL7Server server = new HL7Server(); Assert.That(server.Setup("127.0.0.1", 2012)); Assert.That(server.Start()); Assert.That(hl7Interface.Initialize()); Assert.That(hl7Interface.Start()); bool connected = await hl7Interface.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012)); Assert.That(connected); server.Stop(); hl7Interface.Stop(); }
public void Init() { State = new Ready(); HL7Interface = new HL7Interface.HL7InterfaceBase(); HL7Server server = new HL7Server(); HL7ProtocolBase protocol = new HL7ProtocolBase(new HL7ProtocolConfig() { IsAckRequired = false, IsResponseRequired = false }); server.Setup("127.0.0.1", 2012); server.Start(); HL7Server serverSide = new HL7Server(); serverSide.Setup("127.0.0.1", 50060); HL7Interface.Initialize(serverSide, protocol); HL7Interface.Start(); }
public virtual bool Initialize(HL7Server server, IHL7Protocol protocol) { server.Logger.Debug("the Client side is initializing"); if (protocol.Config == null) { throw new ArgumentNullException("The configuration proprty is missing for this protocol"); } m_HL7Protocol = protocol as HL7ProtocolBase; if (m_HL7Protocol == null) { return(false); } m_HL7Server = server; m_LocalEndpoint = new IPEndPoint(IPAddress.Parse(m_HL7Server.Config.Ip), m_HL7Server.Config.Port); m_EasyClient.Initialize(new ReceiverFilter(m_HL7Protocol), (request) => { if (request.Request.IsAcknowledge) { ProcessIncomingAck(request.Request); } else { ProcessIncomingRequest(request); } }); NewRequestReceived += OnNewRequestReceived; return(true); }