aaa_peer_fsm.h

Diameter协议栈

      AAA_GroupedJob &Job() {
          return *m_GroupedJob.get();
      }    
      virtual int Send(std::auto_ptr<AAAMessage> &msg) {
          ///  If using ASYNC SEND
          ///  EnqueueSendMsg(msg);
          ///  Notify(AAA_PEER_EV_SEND_MESSAGE);
          switch (state) {
              case AAA_PEER_ST_I_OPEN:
                  return RawSend(msg, m_Data.m_IOInitiator.get());
              case AAA_PEER_ST_R_OPEN:
                  return RawSend(msg, m_Data.m_IOResponder.get());
              default:
                  AAA_LOG(LM_INFO, "(%P|%t) Discarding msg to send, peer state is not open\n");
                  break;
          }
          return (0);
      }      

   private: // Event Queue

      typedef struct {
         AAA_Event m_Event;
         std::auto_ptr<AAAMessage> m_Msg;
         std::auto_ptr<AAA_IO_Base> m_IO;
      } AAA_PeerEventParam;

      AAA_ProtectedPtrQueue<AAA_PeerEventParam> m_EventQueue;
      std::auto_ptr<AAA_PeerEventParam> m_CurrentPeerEventParam;

   public:

      virtual void Notify(AAA_Event event) {
         if (AAA_StateMachineWithTimer
             <AAA_PeerStateMachine>::Running()) {
             std::auto_ptr<AAA_PeerEventParam> e(new AAA_PeerEventParam);
             e->m_Event = event;
             m_EventQueue.Enqueue(e);
             Schedule(this);
         }
      }
      virtual void Notify(AAA_Event event,
                          std::auto_ptr<AAAMessage> msg) {
         if (AAA_StateMachineWithTimer
             <AAA_PeerStateMachine>::Running()) {
             std::auto_ptr<AAA_PeerEventParam> e(new AAA_PeerEventParam);
             e->m_Event = event;
             e->m_Msg = msg;
             m_EventQueue.Enqueue(e);
             Schedule(this);
         }
      }
      virtual void Notify(AAA_Event event,
                          std::auto_ptr<AAA_IO_Base> io) {
         if (AAA_StateMachineWithTimer
             <AAA_PeerStateMachine>::Running()) {
             std::auto_ptr<AAA_PeerEventParam> e(new AAA_PeerEventParam);
             e->m_Event = event;
             e->m_IO = io;
             m_EventQueue.Enqueue(e);
             Schedule(this);
         }
      }
      virtual void Notify(AAA_Event event,
                          std::auto_ptr<AAAMessage> msg,
                          std::auto_ptr<AAA_IO_Base> io) {
         if (AAA_StateMachineWithTimer
             <AAA_PeerStateMachine>::Running()) {
             std::auto_ptr<AAA_PeerEventParam> e(new AAA_PeerEventParam);
             e->m_Event = event;
             e->m_Msg = msg;
             e->m_IO = io;
             m_EventQueue.Enqueue(e);
             Schedule(this);
         }
      }
      
   protected: // Constructor/Destructor
 
      AAA_PeerStateMachine(AAA_Task &t) :
          AAA_StateMachineWithTimer<AAA_PeerStateMachine>
             (*this, m_StateTable, *t.reactor()),
          m_GroupedJob(AAA_GroupedJob::Create(t.Job(),
                       (AAA_JobData*)this)) {
      }
      virtual ~AAA_PeerStateMachine() {
          AAA_StateMachine<AAA_PeerStateMachine>::Stop();
          do {
              ACE_Time_Value tv(0, 100000);
              ACE_OS::sleep(tv);
          } while (m_GroupedJob.Job().ExistBacklog());
          m_GroupedJob.Job().Flush(); 
      }    

   protected: // Notifications
      virtual void PeerFsmConnected() {
      }
      virtual void PeerFsmError(int resultCode) {
      }
      virtual void PeerFsmDisconnected(int cause) {
      }
      
   protected: // Job servicing

      ACE_Mutex m_EventFsmMtx;
      virtual int Serve() {
         AAA_MutexScopeLock guard(m_EventFsmMtx);
         m_CurrentPeerEventParam = m_EventQueue.Dequeue();
         DumpEvent(m_CurrentPeerEventParam->m_Event, "Pre-Event");
         try {
             AAA_StateMachineWithTimer
                 <AAA_PeerStateMachine>::Event
                        (m_CurrentPeerEventParam->m_Event);
         }
         catch (AAA_PeerFsmException &err) {
             AAA_LOG(LM_ERROR, "(%P|%t) FSM error[%d]: %s\n",
                        err.Code(), err.Description().data());
         }
         catch (...) {
             AAA_LOG(LM_ERROR, "(%P|%t) Unknown exception in FSM\n");
         }
         DumpEvent(m_CurrentPeerEventParam->m_Event, "Post-Event");
         m_CurrentPeerEventParam.reset();
         return (0);
      }
      virtual int Schedule(AAA_Job* job, size_t backlogSize = 1) {
         if (! AAA_StateMachineWithTimer
             <AAA_PeerStateMachine>::Running()) {
            return (-1);
         }
         return m_GroupedJob->Schedule(job, backlogSize);
      }
      virtual void Timeout(AAA_Event ev) {
         Notify(ev);
      }
      AAA_PeerData &PeerData() {
         return m_Data;
      }
      int RawSend(std::auto_ptr<AAAMessage> &msg, AAA_IO_Base *io);    

   protected: // Capabilities exchange

      virtual void SendCER();
      virtual void SendCEA(diameter_unsigned32_t rcode,
                           std::string &message);
    
      void AssembleCE(AAAMessage &msg,
                      bool request = true);
      void DisassembleCE(AAAMessage &msg);
      bool ValidatePeer(diameter_unsigned32_t &rcode,
                        std::string &message);

   protected: // Watchdog

      virtual void SendDWR();
      virtual void SendDWA(diameter_unsigned32_t rcode,
                           std::string &message);
    
      void AssembleDW(AAAMessage &msg,
                      bool request = true);
      void DisassembleDW(AAAMessage &msg);
    
   protected: // Disconnection

      virtual void SendDPR(bool initiator);
      virtual void SendDPA(bool initiator,
                           diameter_unsigned32_t rcode,
                           std::string &message);
      void AssembleDP(AAAMessage &msg,
                      bool request = true);
      void DisassembleDP(AAAMessage &msg);

   protected: // Message Id's

      void MsgIdTxMessage(AAAMessage &msg);
      bool MsgIdRxMessage(AAAMessage &msg);
   
   protected: // Auxillary

      void Elect();
    
      typedef enum {
          CLEANUP_IO_I = 0x00000001,
          CLEANUP_IO_R = 0x00000002,
          CLEANUP_FSM  = 0x00000004,
          CLEANUP_ALL  = 0xffffffff
      } CLEANUP_FLG;    
      virtual void Cleanup(unsigned int flags = CLEANUP_ALL);

      bool m_CleanupEvent;
      void WaitOnCleanup() {
         m_CleanupEvent = (state != AAA_PEER_ST_CLOSED) ? 
                          false : true;
         do {
             ACE_Time_Value tv(0, 100000);
             ACE_OS::sleep(tv);
         } while (! m_CleanupEvent);
      }
    
   protected:
    
      void DumpPeerCapabilities();
      void DumpEvent(AAA_Event ev, char *prefix) {
#if AAA_FSM_EVENT_DEBUG
          static char *evStrTable[] = { "AAA_PEER_EV_START",  
                                        "AAA_PEER_EV_STOP",
                                        "AAA_PEER_EV_TIMEOUT",  
                                        "AAA_PEER_EV_CONN_RETRY",  
                                        "AAA_PEER_EV_R_CONN_CER",  
                                        "AAA_PEER_EV_I_RCV_CONN_ACK",  
                                        "AAA_PEER_EV_I_RCV_CONN_NACK",
                                        "AAA_PEER_EV_R_RCV_CEA",  
                                        "AAA_PEER_EV_I_RCV_CEA",  
                                        "AAA_PEER_EV_I_PEER_DISC",  
                                        "AAA_PEER_EV_R_PEER_DISC",  
                                        "AAA_PEER_EV_I_RCV_NON_CEA",  
                                        "AAA_PEER_EV_WIN_ELECTION",  
                                        "AAA_PEER_EV_SEND_MESSAGE",  
                                        "AAA_PEER_EV_R_RCV_MESSAGE",  
                                        "AAA_PEER_EV_I_RCV_MESSAGE",  
                                        "AAA_PEER_EV_R_RCV_DWR",  
                                        "AAA_PEER_EV_I_RCV_DWR",
                                        "AAA_PEER_EV_R_RCV_DWA",  
                                        "AAA_PEER_EV_I_RCV_DWA",
                                        "AAA_PEER_EV_R_RCV_DPR",  
                                        "AAA_PEER_EV_I_RCV_DPR",
                                        "AAA_PEER_EV_R_RCV_CER",
                                        "AAA_PEER_EV_I_RCV_CER",
                                        "AAA_PEER_EV_R_RCV_DPA",
                                        "AAA_PEER_EV_I_RCV_DPA",
                                        "AAA_PEER_EV_WATCHDOG"
          };
          static char *stStrTable[] = { "AAA_PEER_ST_CLOSED",
                                        "AAA_PEER_ST_WAIT_CONN_ACK",
                                        "AAA_PEER_ST_WAIT_I_CEA",
                                        "AAA_PEER_ST_WAIT_CONN_ACK_ELECT",
                                        "AAA_PEER_ST_WAIT_RETURNS",
                                        "AAA_PEER_ST_I_OPEN",
                                        "AAA_PEER_ST_R_OPEN",
                                        "AAA_PEER_ST_CLOSING"
          };
          AAA_LOG(LM_INFO, "(%P|%t) FSM EVENT DEBUG [state=%s, event=%s]: %s\n",
                    stStrTable[state], evStrTable[ev], prefix);
#endif // AAA_FSM_EVENT_DEBUG
      }

    public:
      friend class AAA_PeerR_AcceptSendCEA;
      friend class AAA_PeerI_SendCER;
      friend class AAA_Peer_Cleanup;
      friend class AAA_Peer_ConnNack;
      friend class AAA_PeerR_Accept;
      friend class AAA_Peer_Error;
      friend class AAA_Peer_ProcessCEA;
      friend class AAA_PeerR_AcceptElect;
      friend class AAA_Peer_Disconnect;
      friend class AAA_Peer_DisconnectDPA;
      friend class AAA_PeerI_SendCERElect;
      friend class AAA_PeerR_SendCEA;
      friend class AAA_PeerR_SendCEAOpen;
      friend class AAA_PeerR_DisconnectResp;
      friend class AAA_PeerR_DisconnectIOpen;
      friend class AAA_PeerR_Reject;
      friend class AAA_PeerI_DisconnectSendCEA;
      friend class AAA_PeerR_SendMessage;
      friend class AAA_Peer_Process;
      friend class AAA_PeerProcessDWRSendDWA;
      friend class AAA_Peer_ProcessDWA;
      friend class AAA_PeerI_SendDPR;
      friend class AAA_PeerR_SendDPR;
      friend class AAA_PeerI_SendDPADisconnect;
      friend class AAA_PeerR_SendDPADisconnect;
      friend class AAA_PeerI_SendMessage;
      friend class AAA_PeerI_SendCEA;
      friend class AAA_Peer_Watchdog;
    
   private:
    
      AAA_JobHandle<AAA_GroupedJob> m_GroupedJob;    
    
      AAA_PeerData m_Data;
      static AAA_PeerStateTable m_StateTable;
};

#endif /* __AAA_PEER_FSM_H__ */