private void HandleIpcDispatch_EventMessage(object sender, VfxIpcEventArgs args) { if (_mapIpcToFix.ContainsKey(args.Token)) { _mapFixSessions[_mapIpcToFix[args.Token]].HandleRxMessage(args.EventData); } }
/// <summary> /// The HandleIpc_EventMessage event handler is invoked in /// response to the service being notified that the IPC session /// has received some data from the peer system. /// </summary> /// <param name="sender"> /// The IPC session that is dispatching the event. /// </param> /// <param name="args"> /// The details of the IPC event being dispatched. /// </param> private void HandleIpc_EventMessage(object sender, VfxIpcEventArgs args) { lock (_synch) { _fixSession.HandleRxMessage(args.EventData); } }
/// <summary> /// The HandleIpc_EventClosed event handler is invoked in /// response to the service being notified that the session /// has been disconnected from the peer system. /// </summary> /// <param name="sender"> /// The IPC session that is dispatching the event. /// </param> /// <param name="args"> /// The details of the IPC event being dispatched. /// </param> private void HandleIpc_EventClosed(object sender, VfxIpcEventArgs args) { lock (_synch) { // REC: The IPC session is no longer established: _ipcEstablished = false; // REC: Notify the FIX session that the peer system // is no longer connected: _fixSession.HandleDisconnect(); // REC: Adjust the service's current status: _serviceStatus = VfxFixServiceStatus.Service_Status_Disconnected; EventHandler <VfxFixServiceEventArgs> tmpDispatch_Update = EventDispatch; if (tmpDispatch_Update != null) { VfxFixServiceEventArgs tmpArgs = new VfxFixServiceEventArgs(VfxFixServiceEventTypes.Event_Service_Updated, _serviceStatus); tmpDispatch_Update(this, tmpArgs); } // REC: If the service is closing, then the disconnection // of the IPC endpoint is the last thing that needs to be // completed before dispatching the stopped event back up // to the service's owner/subscribers: if (_serviceState == VfxFixServiceStates.Service_State_Closing) { // REC: Adjust the service's current state: _serviceState = VfxFixServiceStates.Service_State_Closed; // REC: Adjust the service's current status: _serviceStatus = VfxFixServiceStatus.Service_Status_Closed; EventHandler <VfxFixServiceEventArgs> tmpDispatch_Stopped = EventDispatch; if (tmpDispatch_Stopped != null) { VfxFixServiceEventArgs tmpArgs = new VfxFixServiceEventArgs(VfxFixServiceEventTypes.Event_Service_Stopped, _serviceStatus); tmpDispatch_Stopped(this, tmpArgs); } } else { // REC: If the service is not configured to reconnect // to the peer system, then it is now stopped: // NOTE: Add reconnect logic here! // REC: Adjust the service's current state: _serviceState = VfxFixServiceStates.Service_State_Closed; // REC: Adjust the service's current status: _serviceStatus = VfxFixServiceStatus.Service_Status_Closed; EventHandler <VfxFixServiceEventArgs> tmpDispatch_Stopped = EventDispatch; if (tmpDispatch_Stopped != null) { VfxFixServiceEventArgs tmpArgs = new VfxFixServiceEventArgs(VfxFixServiceEventTypes.Event_Service_Stopped, _serviceStatus); tmpDispatch_Stopped(this, tmpArgs); } } } }
/// <summary> /// The HandleDispatch event handler is invoked in response to /// one of the IPC sessions dispatching an event to the endpoint. /// </summary> /// <param name="sender"> /// The IPC session that is dispatching the event. /// </param> /// <param name="args"> /// The details of the event being dispatched. The Token property /// of the event args instance will be set to the session id of the /// session that generated the event so that subscribers know which /// of the endpoint's sessions the event originated from. /// </param> private void HandleDispatch(object sender, VfxIpcEventArgs args) { EventHandler <VfxIpcEventArgs> tmp = EventDispatch; if (tmp != null) { tmp(this, args); } }
/// <summary> /// The HandleDispatch event handler is invoked in response /// to an IPC event being dispatched to the session by the /// session's associated IPC module. The session assigns its /// unique identifier to the event and then forwards the event /// up to the server endpoint that owns the session. /// </summary> /// <param name="sender"> /// The IPC module that is dispatching the event. /// </param> /// <param name="args"> /// The details of the event being dispatched. /// </param> private void HandleDispatch(object sender, VfxIpcEventArgs args) { args.Token = _instanceGuid.ToString(); EventHandler <VfxIpcEventArgs> tmp = EventDispatch; if (tmp != null) { tmp(this, args); } }
/// <summary> /// The HandleIpc_EventOpened method is invoked in response /// to the IPC endpoint establishing a connection to the peer /// system that the service is interacting with. /// </summary> /// <param name="sender"> /// The VfxIpcEndpoint that dispatched the event. /// </param> /// <param name="args"> /// The details associated with the event. /// </param> private void HandleIpc_EventOpened(object sender, VfxIpcEventArgs args) { lock (_synch) { // REC: The IPC session is now established. _ipcEstablished = true; // REC: Adjust the service's current status: _serviceStatus = VfxFixServiceStatus.Service_Status_Opened; // REC: Dispatch the update to the service's subscribers: EventHandler <VfxFixServiceEventArgs> tmpDispatch_Update = EventDispatch; if (tmpDispatch_Update != null) { VfxFixServiceEventArgs tmpArgs = new VfxFixServiceEventArgs(VfxFixServiceEventTypes.Event_Service_Updated, _serviceStatus); tmpDispatch_Update(this, tmpArgs); } // REC: Retrieve the version definition from the version // definition registry and determine what kind of session // needs to be created in order to handle the connection: IVfxFixVxRegistry vxRegistry = this._localServices.GetService(typeof(IVfxFixVxRegistry)) as IVfxFixVxRegistry; // REC: Create a new instance of a FIX session to handle // the communication between the server and the peer: IVfxFixSession fixSession = null; // REC: Check the version definition in order to tell if // this is a FIX 4.x or FIX 5.x service: VfxFixVxRecord vxRecord = vxRegistry.Get(this._sxVersion); if (vxRecord.Layer.ToLower().CompareTo("combined") == 0) { fixSession = new VfxFix4xClientSession(); } else { fixSession = new VfxFix5xClientSession(); } _fixSession = fixSession; // REC: Initialize the session: _fixSession.Init(this._localServices, this); // REC: Construct an instance of the session wrapper // for the FIX application and bind it to the session // implementation that has been created: _appSession = new VfxFixClientSession(_fixSession); // REC: Notify the FIX session implementation that it // has been connected to a peer system: _fixSession.HandleConnect(); } }
/// <summary> /// The HandleIpc_Dispatch method is invoked in response /// to the IPC session handler dispatching an IPC event to /// the endpoint. The event is simply forwarded to the owner /// of the endpoint instance for processing. /// </summary> /// <param name="sender"> /// The IPC session that is dispatching the event. /// </param> /// <param name="args"> /// The details of the IPC event being dispatched. /// </param> private void HandleIpc_Dispatch(object sender, VfxIpcEventArgs args) { // REC: The incoming event from the underlying IPC session // is simply forwarded to the endpoint's owner: EventHandler <VfxIpcEventArgs> tmp = EventDispatch; if (tmp != null) { tmp(this, args); } }
/// <summary> /// The HandleTcpConnector_Failure event handler is invoked /// in response to the connector not being able to establish /// a connection to the peer system. /// </summary> /// <param name="sender"> /// The connector that is dispatching the event. /// </param> /// <param name="args"> /// The event details that are associated with the event. /// </param> private void HandleTcpConnector_Failure(object sender, VfxTcpConnectorEventArgs args) { // REC: Translate the connector's failure notification // into the corresponding IPC event and dispatch it: EventHandler <VfxIpcEventArgs> tmpDispatch = EventDispatch; if (tmpDispatch != null) { VfxIpcEventArgs tmpArgs = new VfxIpcEventArgs(VfxIpcEventTypes.Event_Connect_Failure); tmpDispatch(this, tmpArgs); } }
/// <summary> /// The HandleIpcDispatch_EventOpened event handler is invoked in /// response to a new session being established between a peer /// system and the endpoint associated with the service. /// </summary> /// <param name="sender"> /// The IPC endpoint that dispatched the event. /// </param> /// <param name="args"> /// The details of the event being dispatched. /// </param> private void HandleIpcDispatch_EventOpened(object sender, VfxIpcEventArgs args) { // REC: Create a new instance of a FIX session to handle // the communication between the server and the peer: IVfxFixSession fixSession = null; // REC: Retrieve the version definition from the version // definition registry and determine what kind of session // needs to be created in order to handle the connection: IVfxFixVxRegistry vxRegistry = this._localServices.GetService(typeof(IVfxFixVxRegistry)) as IVfxFixVxRegistry; // REC: Check the version definition in order to tell if // this is a FIX 4.x or FIX 5.x service: VfxFixVxRecord vxRecord = vxRegistry.Get(this._sxVersion); if (vxRecord.Layer.ToLower().CompareTo("combined") == 0) { fixSession = new VfxFix4xServerSession(); } else { fixSession = new VfxFix5xServerSession(); } // REC: Initialize the session: fixSession.Init(_localServices, this); // REC: Create an entry for the session in the // local session map: _mapFixSessions.Add(fixSession.InstanceId, fixSession); // REC: Bind the FIX session to the IPC session: _mapFixToIpc.Add(fixSession.InstanceId, args.Token); // REC: Bind the IPC session to the FIX session: _mapIpcToFix.Add(args.Token, fixSession.InstanceId); // REC: Create the application session container // that will be passed to the app implementation // when events are generated on the session: VfxFixServerSession appSession = new VfxFixServerSession(fixSession); // REC: Create a binding between the FIX session // and the application session so that events from // the FIX session can be correlated to the correct // application session when events are dispatched to // the user's FIX application instance: _mapAppSessions.Add(fixSession.InstanceId, appSession); // REC: Inform the session that a peer system // has been connected to it: fixSession.HandleConnect(); }
/// <summary> /// The HandleIpc_Dispatch event handler is invoked in /// response to the IPC endpoint dispatching an event to /// an instance of the service. The service demultiplexes /// the dispatched event to the appropriate handler. /// </summary> /// <param name="sender"> /// The IPC endpoint that generated the event. /// </param> /// <param name="args"> /// The IPC event details for the dispatched event. /// </param> private void HandleIpc_Dispatch(object sender, VfxIpcEventArgs args) { switch (args.EventType) { case VfxIpcEventTypes.Event_Session_Opened: HandleIpc_EventOpened(sender, args); break; case VfxIpcEventTypes.Event_Session_Message: HandleIpc_EventMessage(sender, args); break; case VfxIpcEventTypes.Event_Session_Closed: HandleIpc_EventClosed(sender, args); break; } }
/// <summary> /// The HandleIpcDispatch_EventClosed event handler is invoked /// when an IPC session disconnects from a peer system. /// </summary> /// <param name="sender"> /// The IPC session that dispatched the event. /// </param> /// <param name="args"> /// The details of the event being dispatched. /// </param> private void HandleIpcDispatch_EventClosed(object sender, VfxIpcEventArgs args) { // REC: Determine if there is currently an instance of // a FIX session associated with the IPC session: if (_mapIpcToFix.ContainsKey(args.Token)) { // REC: Remove the binding between the FIX session // and the IPC session, since the IPC session has been // disconnected and can not be used by the FIX session // for any other operations: if (_mapFixToIpc.ContainsKey(_mapIpcToFix[args.Token])) { _mapFixToIpc.Remove(_mapIpcToFix[args.Token]); } // REC: Notify the associated FIX session that the // connection has been broken: _mapFixSessions[_mapIpcToFix[args.Token]].HandleDisconnect(); } }