aaa_session_acct_client_fsm.h

Diameter协议栈

           -------------------------------------------------------------
           PendingS  User service terminated        Store      PendingS
                                                    stop
                                                    record
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_S,
                           AAA_SESSION_ACCT_EV_STOP,
                           AAA_SESSION_ACCT_ST_PENDING_S,
                           m_acStoreStopRecord);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
            PendingS Any                            None       PendingS
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_S,
                                   AAA_SESSION_ACCT_ST_PENDING_S);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           Open      Interim interval elapses       Send       PendingI
                                                    accounting
                                                    interim
                                                    record
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_OPEN,
                           AAA_SESSION_ACCT_EV_INT_EXPIRE,
                           AAA_SESSION_ACCT_ST_PENDING_I,
                           m_acInterimTimeout);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           Open      User service terminated        Send       PendingL
                                                    accounting
                                                    stop   
                                                    record
         */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_OPEN,
                           AAA_SESSION_ACCT_EV_STOP,
                           AAA_SESSION_ACCT_ST_PENDING_L,
                           m_acTxACR);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           Open      Any                            None       Open
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_OPEN,
                                   AAA_SESSION_ACCT_ST_OPEN);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Successful accounting                     Open
                     interim answer received
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_RX_ACA_OK,
                           AAA_SESSION_ACCT_ST_OPEN,
                           m_acRxACASuccess);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Failure to send and buffer     Store      Open
                     space available and realtime   Interim
                     not equal to DELIVER_AND_GRANT Record
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_FTS_NOT_DAG,
                           AAA_SESSION_ACCT_ST_OPEN,
                           m_acStoreInterimRecord);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Failure to send and no buffer             Open
                     space available and realtime
                     equal to GRANT_AND_LOSE
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_FTS_AND_GAL,
                           AAA_SESSION_ACCT_ST_OPEN,
                           m_acStartIntTimer);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Failure to send and no buffer  Disconnect Idle
                     space available and realtime   user/dev
                     not equal to
                     GRANT_AND_LOSE
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_FTS_NOT_GAL,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acDisconnect);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Failed accounting interim answer            Open
                     received and realtime equal
                     to GRANT_AND_LOSE
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_RX_ACA_FAIL_AND_GAL,
                           AAA_SESSION_ACCT_ST_OPEN,
                           m_acStartIntTimer);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Failed accounting interim answer Disconnect Idle
                     received and realtime not        user/dev
                     equal to GRANT_AND_LOSE
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_RX_ACA_FAIL_NOT_GAL,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acDisconnect);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  User service terminated        Store      PendingI
                                                    stop
                                                    record
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                           AAA_SESSION_ACCT_EV_STOP,
                           AAA_SESSION_ACCT_ST_PENDING_I,
                           m_acStoreStopRecord);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingI  Any                            None       PendingI
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_I,
                                   AAA_SESSION_ACCT_ST_PENDING_I);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingE  Successful accounting                     Idle
                     event answer received
	 */
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_E,
                           AAA_SESSION_ACCT_EV_RX_ACA_OK,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acRxACASuccess);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingE  Failure to send and buffer     Store      Idle
                     space available                event
                                                    record
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_E,
                           AAA_SESSION_ACCT_EV_FTS_BUF,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acStoreEventRecord);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingE  Failure to send and no buffer             Idle
                     space available
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_E,
                           AAA_SESSION_ACCT_EV_FTS_NO_BUF,
                           AAA_SESSION_ACCT_ST_IDLE);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingE  Failed accounting event answer            Idle
                     received
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_E,
                           AAA_SESSION_ACCT_EV_RX_ACA_FAIL,
                           AAA_SESSION_ACCT_ST_IDLE);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingE  Any                            None       PendingE
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_E,
                                   AAA_SESSION_ACCT_ST_PENDING_E);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingB  Successful accounting answer   Delete     Idle
                     received                       record
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_B,
                           AAA_SESSION_ACCT_EV_RX_ACA_OK,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acRxACASuccess);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingB  Failure to send                           Idle
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_B,
                           AAA_SESSION_ACCT_EV_FTS,
                           AAA_SESSION_ACCT_ST_IDLE);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingB  Failed accounting answer       Delete     Idle
                     received                       record
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_B,
                           AAA_SESSION_ACCT_EV_RX_ACA_FAIL,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acDeleteRecord);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingB  Any                            None       PendingB
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_B,
                                   AAA_SESSION_ACCT_ST_PENDING_B);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingL  Successful accounting                     Idle
                     stop answer received
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_L,
                           AAA_SESSION_ACCT_EV_RX_ACA_OK,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acRxACASuccess);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingL  Failure to send and buffer     Store      Idle
                     space available                stop
                                                    record
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_L,
                           AAA_SESSION_ACCT_EV_FTS_BUF,
                           AAA_SESSION_ACCT_ST_IDLE,
                           m_acStoreStopRecord);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingL  Failure to send and no buffer             Idle
                     space available
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_L,
                           AAA_SESSION_ACCT_EV_FTS_NO_BUF,
                           AAA_SESSION_ACCT_ST_IDLE);

	/*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingL  Failed accounting stop answer             Idle
                     received
	*/
        AddStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_L,
                           AAA_SESSION_ACCT_EV_RX_ACA_FAIL,
                           AAA_SESSION_ACCT_ST_IDLE);

        /*
           State     Event                          Action     New State
           -------------------------------------------------------------
           PendingL  Any                            None       PendingL
         */
        AddWildcardStateTableEntry(AAA_SESSION_ACCT_ST_PENDING_L,
                                   AAA_SESSION_ACCT_ST_PENDING_L);

        InitialState(AAA_SESSION_ACCT_ST_IDLE); 
      }

      static AAA_SessAcctClientStateTable &Instance() {
        return m_AcctClientStateTable;
      }

   private:
      AAA_SessAcctClient_TxACR               m_acTxACR;
      AAA_SessAcctClient_RxACA_Success       m_acRxACASuccess;
      AAA_SessAcctClient_InterimTimout       m_acInterimTimeout;
      AAA_SessAcctClient_StoreStartRecord    m_acStoreStartRecord;
      AAA_SessAcctClient_StoreStopRecord     m_acStoreStopRecord;
      AAA_SessAcctClient_StoreInterimRecord  m_acStoreInterimRecord;
      AAA_SessAcctClient_StoreEventRecord    m_acStoreEventRecord;
      AAA_SessAcctClient_StartIntTimer       m_acStartIntTimer;
      AAA_SessAcctClient_DeleteRecord        m_acDeleteRecord;
      AAA_SessAcctClient_Disconnect          m_acDisconnect;

   private:
      static AAA_SessAcctClientStateTable m_AcctClientStateTable;
};

#endif /* __AAA_SESSION_ACCT_CLIENT_FSM_H__ */