def __init__(self):
# Fault Manager init a /tmp/fm_sock and wait for rsyslog to send ERROR logs to it.
self.fm_sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
self.fm_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.fm_sock.bind('/tmp/fm_sock')
# restore fault json file log
rpd_event_def.EventCommonOperation.restore_log()
# create a dispatcher
self.dispatcher = Dispatcher()
self.fault_ipc = FaultManagementClient(
"FaultManager", "This is for Fault management", "1.0.0",
self.dispatcher,
(MsgTypeRpdGlobal, MsgTypetEventNotification, MsgTypeRpdCtrl),
(MsgTypeFaultManagement, ), (MsgTypeSetLed, ), self.send_fault_msg)
self.fault_ipc.start()
self.dispatcher.fd_register(self.fm_sock.fileno(),
self.dispatcher.EV_FD_IN,
self.fm_syslog_trigger)
self.schedule_send_timer = self.dispatcher.timer_register(
FaultManager.REPORT_CHECK_INTERVAL, self.schedule_fault_msg)
self.clear_msg_cnt_timer = self.dispatcher.timer_register(
rpd_event_def.RpdEventConfig.GLOBAL_CONFIG["Interval"],
self.clear_msg_cnt)
self.msg_cnt_in_interval = 0
self.msg_cnt_in_sec = 0
self.poll_local_timer = None
self.poll_pending_timer = None
self.clear_operational_tag_in_buffer()
def _main():
"""The _main function, setup the dispatcher and the API part.
:return: None
"""
global_dispatcher = Dispatcher()
l2tp_dispatcher = L2tpv3Dispatcher.L2tpv3Dispatcher(
global_dispatcher,
L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress)
L2tpv3GlobalSettings.L2tpv3GlobalSettings.Dispatcher = l2tp_dispatcher
# setup the halclient
hal_client = L2tpHalClient("L2TP_HAL_CLIENT",
"the HAL client of L2TP feature", "1.0",
tuple(L2tpHalClient.notification_list.keys()),
global_dispatcher,
L2tpHalClient.supportmsg_list)
L2tpv3GlobalSettings.L2tpv3GlobalSettings.l2tp_hal_client = hal_client
hal_client.start(l2tp_dispatcher.receive_hal_message)
# Construct the API transport path
ApiPath = L2tpv3GlobalSettings.L2tpv3GlobalSettings.APITransportPath
print ApiPath
api = L2tpv3API.L2tpv3API(ApiPath)
l2tp_dispatcher.register_zmq(api)
l2tp_dispatcher.register_remote_address()
global_dispatcher.loop()
class HostManager(object):
__metaclass__ = AddLoggerToClass
UPD_CRASH_FILE_TIME = 2
def __init__(self):
# create a dispatcher
self.dispatcher = Dispatcher()
self.driver_client =\
RpdResHalClient("RpdHostRes_hal",
"This is RPD Resources hal client",
"1.0.0", self.dispatcher,
(MsgTypeHostResources, MsgTypeRpdCtrl), ())
self.driver_client.start()
self.crash_ctrl_timer = self.dispatcher.timer_register(
HostManager.UPD_CRASH_FILE_TIME,
self.driver_client.crashFileCtrlHandler.update_crash_file_table,
None,
timer_type=DpTimerManager.TIMER_REPEATED)
def host_run(self):
self.dispatcher.loop()
def setUpClass(cls):
create_db_conf()
start_redis()
RCPDB.DB_CFG_FILE = CONF_FILE
cls.master_thread = None
cls.slave_thread = None
cls.master_disp = Dispatcher()
cls.slave_disp = Dispatcher()
cls.master_orchestrator = None
cls.slave_orchestrator = None
cls.setup_master()
time.sleep(3)
cls.setup_slave()
def __init__(self):
self.disp = Dispatcher()
self.it_api_server = ItApiServerServiceSuite(rx_cb=self._ip_api_rx_cb,
disp=self.disp)
self.orchestrator = RCPMasterOrchestrator(self.disp)
self.services = [
DhcpV4Config(),
DhcpV6Config(),
TpConfig(),
CcapV4Config(self.orchestrator),
CcapV6Config(self.orchestrator)
]
def demoL2tp():
print "demoL2tp thread start!"
setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG)
drv_logger = logging.getLogger("demoL2tp")
drv_logger.info("hello demoL2tp Log")
dispatcher = Dispatcher()
l2tp_dispatcher = L2tpv3Dispatcher(
dispatcher,
local_addr=None,
# since we don't create global listen, set it to None
create_global_listen=False)
L2tpv3GlobalSettings.Dispatcher = l2tp_dispatcher
# setup the halclient
SupportedCfgMsg = list()
SupportedCfgMsg.append(MsgTypeVspAvpExchange)
notificationMsg = list()
notificationMsg.append(MsgTypeL2tpv3SessionStatusNotification)
hal_client = L2tpHalClient("L2TP_HAL_CLIENT",
"the HAL client of L2TP feature", "1.0",
tuple(notificationMsg), dispatcher,
SupportedCfgMsg)
L2tpv3GlobalSettings.l2tp_hal_client = hal_client
hal_client.start(l2tp_dispatcher.receive_hal_message)
if L2tpv3GlobalSettings.l2tp_hal_client:
print("setup l2tp hal client successfully")
if L2tpv3GlobalSettings.Dispatcher:
print("l2tp_dispatcher is OK")
print l2tp_dispatcher
l2tp_dispatcher.dispatcher.loop()
print "demoL2tp thread done!"
def test_recvSLI(self):
conn_address = '127.11.2.17'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.19'
conn = L2tpConnection(18, 18, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
localSessionID = session.remoteSessionId
localAvp = LocalSessionID(localSessionID)
avp1 = ControlMessageAVP(ControlMessageAVP.SLI)
avp2 = CallSerialNumber()
avps = [avp1, avp2]
avps.append(localAvp)
sli = L2tpv3ControlPacket(0, 0, 1, avps)
self.assertEqual(sli.length, 40)
self.assertEqual(sli.avps[0].messageType, ControlMessageAVP.SLI)
ret = conn.recvSLI(sli)
self.assertIsNone(ret)
# Abnormal SLI message
avps = list()
sli = L2tpv3ControlPacket(0, 0, 1, avps)
ret = conn.HandlePkt(sli)
self.assertIsNone(ret)
conn.CloseConnection()
def test_recvCDN(self):
conn_address = '127.11.2.14'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.16'
conn = L2tpConnection(15, 15, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
localSessionID = session.remoteSessionId
localAvp = LocalSessionID(localSessionID)
avp = ControlMessageAVP(ControlMessageAVP.CDN)
avps = [avp]
avps.append(localAvp)
cdn = L2tpv3ControlPacket(0, 0, 1, avps)
self.assertEqual(cdn.length, 30)
self.assertEqual(cdn.avps[0].messageType, 14)
conn.HandlePkt(cdn)
self.assertEqual(conn.fsm.current, 'idle')
conn.CloseConnection()
def testHandlePkt_FirstAvpIsNotControlAvp(self):
"""Handle control packet: the first avp is not control avp.
:return:
"""
conn_address = '127.11.2.4'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.6'
conn = L2tpConnection(5, 5, conn_address, local_addr)
avp1 = Hostname("TestAVP")
avp2 = ControlMessageAVP(ControlMessageAVP.SCCRQ)
avp3 = RouterID(0)
avp4 = AssignedControlConnectionID(1)
avp5 = PseudowireCapList(())
avps = [avp1, avp2, avp3, avp4, avp5]
sccrq = L2tpv3ControlPacket(0x1234, 0, 1, avps)
ret = conn.HandlePkt(sccrq)
self.assertIsNone(ret)
conn.CloseConnection()
self.assertIsNone(ret)
def demoRCP():
print "demoRCP thread start!"
setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG)
drv_logger = logging.getLogger("demoRCP")
drv_logger.info("hello demoRCP Log")
RcpGlobalSettings.gDispatcher = Dispatcher()
rcpProcess = RcpHalProcess("ipc:///tmp/_test_rcp_to_hal.tmp",
RcpGlobalSettings.gDispatcher)
RcpGlobalSettings.hal_ipc = RcpHalIpc("RCP-HalClient",
"This is a RCP test application",
"1.9.0", (1, 100, 102),
rcpProcess,
"../hal/conf/ClientLogging.conf",
shadowLayerConf=TMP_CFG_PATH)
try:
if None is not RcpGlobalSettings.hal_ipc:
RcpGlobalSettings.hal_ipc.start(
rcpProcess.orchestrator.config_operation_rsp_cb,
rcpProcess.orchestrator.notification_process_cb)
RcpGlobalSettings.gDispatcher.loop()
else:
print("demoRCP: hal_ipc is NONE")
except Exception:
print("socket is destroyed, demoRCP terminated")
print "demoRCP thread done!"
def test_recvHELLO(self):
conn_address = '127.11.2.16'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.18'
conn = L2tpConnection(17, 17, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
localSessionID = session.remoteSessionId
localAvp = LocalSessionID(localSessionID)
avp = ControlMessageAVP(ControlMessageAVP.HELLO)
avps = [avp]
avps.append(localAvp)
hello = L2tpv3ControlPacket(0, 0, 1, avps)
self.assertEqual(hello.length, 30)
self.assertEqual(hello.avps[0].messageType, 6)
zlb = conn.HandlePkt(hello)
self.assertEqual(zlb.length, 12)
conn.CloseConnection()
def test_add_remove_find_Session(self):
conn_address = '127.11.2.21'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.23'
conn = L2tpConnection(22, 22, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'sender', conn)
session1 = None
conn.addSession(session)
conn.addSession(session1)
self.assertEqual(conn.sessions.keys(), [1])
self.assertEqual(conn.sessionsByRemoteSessionId.keys(), [2])
self.assertIsNotNone(
conn.findSessionByLocalSessionID(session.localSessionId))
self.assertIsNotNone(
conn.findSessionByRemoteSessionID(session.remoteSessionId))
conn.removeSession(session)
self.assertEqual(conn.sessions.keys(), [])
self.assertEqual(conn.sessionsByRemoteSessionId.keys(), [])
self.assertIsNone(
conn.findSessionByLocalSessionID(session.localSessionId))
self.assertIsNone(
conn.findSessionByRemoteSessionID(session.remoteSessionId))
conn.CloseConnection()
def test_resetTransport(self):
conn_address = '127.11.2.33'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.35'
conn = L2tpConnection(18, 18, conn_address, local_addr)
avp = ControlMessageAVP(ControlMessageAVP.HELLO)
avps = [avp]
hello = L2tpv3ControlPacket(0, 0, 1, avps)
conn.transport.sendList.append({
"time": 1,
"pkt": hello,
"sendTimes": 0,
})
conn.transport.receiveWindow.add(hello)
conn.transport.ackNr = 105
conn.transport.ns = 56
conn.resetTransport()
self.assertFalse(conn.transport.sendList)
self.assertFalse(conn.transport.receiveWindow)
self.assertEqual(conn.transport.ackNr, 0)
self.assertEqual(conn.transport.ackNr, 0)
conn.CloseConnection()
def testConnection_init(self):
conn_address = '127.11.2.1'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.2'
# localConnectionID not equal to zero
conn1 = L2tpConnection(1, 1, conn_address, local_addr)
session1 = L2tpv3Session(1, 2, 'sender', conn1)
conn1.addSession(session1)
self.assertEqual(conn1.sessions.keys(), [1])
self.assertEqual(conn1.sessionsByRemoteSessionId.keys(), [2])
self.assertEqual(conn1.localConnID, 1)
self.assertIsNotNone(conn1.ConnectionDb)
# localConnectionID equal to zero
local_addr = '127.11.2.3'
conn2 = L2tpConnection(0, 2, conn_address, local_addr)
session2 = L2tpv3Session(1, 2, 'sender', conn2)
conn2.addSession(session2)
self.assertEqual(conn2.sessions.keys(), [1])
self.assertEqual(conn2.sessionsByRemoteSessionId.keys(), [2])
self.assertIsNotNone(conn2.localConnID)
self.assertIsNotNone(conn2.ConnectionDb)
conn1.CloseConnection()
conn2.CloseConnection()
def test_recvFSQ(self):
"""Handle control packet: FSQ.
Function: recvFSQ.
:return:
"""
conn_address = '127.11.2.28'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = True
local_addr = '127.11.2.30'
conn = L2tpConnection(18, 18, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
avp1 = ControlMessageAVP(ControlMessageAVP.FSQ)
avp2 = FailoverSessionState(session.remoteSessionId, session.localSessionId)
avp3 = FailoverSessionState(4, 5)
avps = [avp1, avp2, avp3]
fsq = L2tpv3ControlPacket(0, 0, 1, avps)
fsr = conn.HandlePkt(fsq)
self.assertIsNotNone(fsr)
self.assertEqual(fsr.avps[1].sessionID, 1)
self.assertEqual(fsr.avps[1].remoteSessionID, 2)
self.assertEqual(fsr.avps[2].sessionID, 0)
self.assertEqual(fsr.avps[2].remoteSessionID, 4)
conn.CloseConnection()
def test_recvFSR(self):
"""Handle control packet: FSR.
Function: recvFSR.
:return:
"""
conn_address = '127.11.2.29'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.31'
conn = L2tpConnection(18, 18, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
avp1 = ControlMessageAVP(ControlMessageAVP.FSR)
avp2 = FailoverSessionState(session.remoteSessionId, session.localSessionId)
avps = [avp1, avp2]
fsr = L2tpv3ControlPacket(0, 0, 1, avps)
ret = conn.HandlePkt(fsr)
self.assertIsNone(ret)
conn.CloseConnection()
def test_handleStatsQuery(self):
cmd = l2tpMsg.L2tpCommandReq()
cmd.cmd = l2tpMsg.STATS_INFO
msg = self.api._handleMsg(cmd)
L2tpv3GlobalSettings.L2tpv3GlobalSettings.Dispatcher = None
L2tpv3GlobalSettings.L2tpv3GlobalSettings.l2tp_hal_client = None
print msg
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher.L2tpv3Dispatcher(global_dispatcher,
"127.0.0.1", False,
None)
L2tpv3GlobalSettings.L2tpv3GlobalSettings.Dispatcher = dispatcher
dispatcher.stats.exception = 1
dispatcher.stats.zmq_error = 1
dispatcher.stats.error = 1
# setup the halclient
hal_client = L2tpHalClient("L2TP_HAL_CLIENT",
"the HAL client of L2TP feature", "1.0",
(3078, ), global_dispatcher)
L2tpv3GlobalSettings.L2tpv3GlobalSettings.l2tp_hal_client = hal_client
hal_client.stats.exception = 10
msg = self.api._handleMsg(cmd)
print msg
hal_client.stats = None
def testStopConnection(self):
conn_address = '127.11.2.26'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
L2tpv3GlobalSettings.l2tp_hal_client = fake_hal()
local_addr = '127.11.2.27'
L2tpConnection.ConnectionDb.clear()
conn = L2tpConnection(3, 3, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
conn.ReceiveHalMsg(msg=None)
msg = L2tpv3Hal_pb2.t_l2tpLcceAssignmentRsp()
msg.result = False
try:
conn.ReceiveHalMsg(msg)
except Exception as e:
pass
msg.result = True
conn.ReceiveHalMsg(msg)
conn.SendHalMsg(msg_type=L2tpConnection.ADD_LCCE)
conn.fsmEventrecvBadSCCRP(event=None)
conn.fsmEventrecvSCCRQLoseTieGood(event=None)
conn.fsmEventrecvSCCRQLoseTieBad(event=None)
conn.fsmEventrecvSCCRQWinSCCRQ(event=None)
conn.fsmEventcloseRequest(event=None)
conn.fsmEventHalError(event=None)
conn.StopConnection()
conn.StopConnection()
self.assertEqual(len(conn.ConnectionDb), 0)
L2tpv3GlobalSettings.l2tp_hal_client = None
def test_A2__handleConnectionQuery_connID_isin_connDB(self):
"""(remoteAddr, connID) is in connectionDb Create a connection.
Result: success.
"""
# Create a connection
global_dispatcher = Dispatcher()
L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress = '127.0.0.1'
dispatcher = L2tpv3Dispatcher.L2tpv3Dispatcher(
global_dispatcher,
L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress,
create_global_listen=False)
self.dispatcher = L2tpv3GlobalSettings.L2tpv3GlobalSettings.Dispatcher = dispatcher
self.connection = L2tpv3Connection.L2tpConnection(
9527, 21203, "127.0.0.1")
# Create a msg
cmd = l2tpMsg.L2tpCommandReq()
cmd.cmd = l2tpMsg.CONNECTION_INFO
# connection is in local connection DB
para = l2tpMsg.ConnectionPara()
# Get addr and connID invoke connection
para.remoteAddr = self.connection.remoteAddr
para.connectionID = self.connection.localConnID
para.localAddr = L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress
cmd.conn.MergeFrom(para)
msg = self.api._handleMsg(cmd)
# SUCCESS = 1
self.assertEqual(msg.rsp, 1)
def test_recvICRP(self):
conn_address = '127.11.2.15'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.17'
conn = L2tpConnection(16, 16, conn_address, local_addr)
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
localSessionID = session.remoteSessionId
localAvp = LocalSessionID(localSessionID)
avp = ControlMessageAVP(ControlMessageAVP.ICRP)
avps = [avp]
avps.append(localAvp)
icrp = L2tpv3ControlPacket(0, 0, 1, avps)
self.assertEqual(icrp.length, 30)
self.assertEqual(icrp.avps[0].messageType, 11)
ret = conn.HandlePkt(icrp)
self.assertIsNone(ret)
conn.CloseConnection()
def setUpClass(cls):
cls.text = "00000000000000000"
setup_test_redis()
os.system("mkdir -p /tmp/crash/")
global_dispatcher = Dispatcher()
CrashFileStatusInfo.MAX_IDX = 20
crashFileStatusInfo = CrashFileStatusInfo()
CrashFileCtrlHandler.CORE_FILE_PATH = "/tmp/crash/"
crashFileStatusInfo.CORE_FILE_PATH = "/tmp/crash/"
currentPath = os.path.dirname(os.path.realpath(__file__))
dirs = currentPath.split("/")
rpd_index = dirs.index("testing") - 2
cls.rootpath = "/".join(dirs[:rpd_index])
cls.halClient = RpdResHalClient("RpdRes_hal",
"This is RPD HostRes hal client",
"1.0.0", global_dispatcher,
(MsgTypeHostResources, MsgTypeRpdCtrl, ),
())
cls.crashCtrlHandler = cls.halClient.crashFileCtrlHandler
cls.crashCtrlHandler.CORE_FILE_PATH = "/tmp/crash/"
cls.start_tftp_cmd = \
"coverage run --parallel-mode --rcfile=" + \
cls.rootpath + "/.coverage.rc " + \
cls.rootpath + \
"/rpd/resource/testing/tftp_server_sim.py --root " + \
cls.rootpath + " --server 127.0.0.1 --port " + \
str(cls.TFTP_PORT)
cls.tftp_pid = subprocess.Popen(cls.start_tftp_cmd, executable='bash', shell=True)
print(cls.tftp_pid)
def test_recvICCN(self):
conn_address = '127.11.2.13'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.15'
conn = L2tpConnection(14, 14, conn_address, local_addr)
session = L2tpv3Session(3, 4, 'receive', conn)
conn.addSession(session)
# localSessionID = session.remoteSessionId
remoteSessionID = session.localSessionId
# localAvp = LocalSessionID(localSessionID)
remoteAvp = RemoteSessionID(remoteSessionID)
# Normal case, session is not none
avp = ControlMessageAVP(ControlMessageAVP.ICCN)
avps = [avp]
avps.append(remoteAvp)
iccn = L2tpv3ControlPacket(0, 0, 1, avps)
self.assertEqual(iccn.length, 30)
self.assertEqual(iccn.avps[0].messageType, 12)
ret = conn.HandlePkt(iccn)
self.assertIsNotNone(ret)
self.assertIsInstance(ret, L2tpv3ACK)
conn.CloseConnection()
def test_recvICRQ_normal_1(self):
"""Handle control packet: ICRQ, session exist.
:return: none
"""
conn_address = '127.11.2.11'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.13'
conn = L2tpConnection(12, 12, conn_address, local_addr)
icrq = L2tpv3ControlPacket.decode(self.ircq_buf)
icrp = conn.HandlePkt(icrq)
print icrp
self.assertEqual(icrp.connectionID, 12)
ret = conn.checkMustAvps(
L2tpv3ControlPacket.ICRPMandatoryAVPs, icrp.avps)
self.assertTrue(ret)
self.assertEqual(icrp.avps[0].messageType, ControlMessageAVP.ICRP)
session = conn.findSessionByRemoteSessionID(0x40000001)
self.assertIsNotNone(session)
conn.CloseConnection()
def setUp(self):
setup_test_redis()
self.local_addr = "127.0.0.1"
self.global_dispatcher = Dispatcher()
self.l2tp_dispatcher = L2tpv3Dispatcher(
dispatcher=self.global_dispatcher,
create_global_listen=False,
local_addr=self.local_addr)
L2tpv3GlobalSettings.Dispatcher = self.l2tp_dispatcher
self.local_addr = "::1"
self.global_dispatcher = Dispatcher()
self.l2tp_dispatcher = L2tpv3Dispatcher(
dispatcher=self.global_dispatcher,
create_global_listen=False,
local_addr=self.local_addr)
L2tpv3GlobalSettings.Dispatcher = self.l2tp_dispatcher
def setUpClass(cls):
setup_logging("GCP", filename="rcp.log")
cls.dispatcher = Dispatcher()
cls.desc = GCPSlaveDescriptor(addr_master='localhost',
interface_local='local')
cls.session = RCPSlaveSession(cls.desc, cls.dispatcher, fake_cb,
fake_cb, fake_cb)
def setUpClass(cls):
setup_logging("PROVISION", "test.log")
cls.dispatcher = Dispatcher()
cls.mgr = FakeManager()
currentPath = os.path.dirname(os.path.realpath(__file__))
dirs = currentPath.split("/")
rpd_index = dirs.index("testing") + 1
cls.rootpath = "/".join(dirs[:rpd_index])
def setUpClass(cls):
create_db_conf()
start_redis()
RCPDB.DB_CFG_FILE = CONF_FILE
cls.dispatcher = Dispatcher()
cls.desc = GCPSlaveDescriptor(addr_master='localhost',
interface_local='local')
cls.session = RCPSlaveSession(cls.desc, cls.dispatcher, fake_cb,
fake_cb, fake_cb)
def setUpClass(cls):
setup_test_redis()
global_dispatcher = Dispatcher()
cls.rpdhostres = RpdResHalClient("RpdHostRes_hal",
"This is RPD HostRes hal client",
"1.0.0", global_dispatcher, (
MsgTypeHostResources,
MsgTypeRpdCtrl,
), ())
def __init__(self, agent_type):
if agent_type not in self.AgentName:
self.logger.error("Cannot setup the process agent for type:%d" %
agent_type)
raise ProcessAgentError("Unknown Type:%d" % agent_type)
if self._process_is_running(agent_type):
self.logger.error(
"Cannot setup the process agent for %s since a same agent has been up",
agent_type)
raise ProcessAgentError("Cannot setup a duplicated %s" %
self.AgentName[agent_type])
event_path = self.SockPathMapping[agent_type]["pull"]
api_path = self.SockPathMapping[agent_type]["api"]
cli_path = self.SockPathMapping[agent_type]["cli"]
# Create the pull and api sock to handle the request
self.event_transport = Transport(event_path, Transport.PULLSOCK)
self.api_transport = Transport(api_path, Transport.REPSOCK)
self.cli_transport = Transport(cli_path, Transport.REPSOCK)
# create a dispatcher
self.dispatcher = Dispatcher()
# register the event
self.register_transport(self.event_transport,
self._process_event_callback, None)
self.register_transport(self.api_transport, self.api_event_callback,
None)
self.register_transport(self.cli_transport, self._process_cli_callback,
None)
# the region to hold all the process obj
self.processes = {}
# the region to hold all the ccap cores
self.ccap_cores = {}
self.mgrs = {}
# agent information maintain
self.name = self.AgentName[agent_type]
self.id = agent_type # we will generate uuid
def testHandlePkt_SCCCN(self):
"""Handle control packet: SCCCN.
Function: recvSCCCN.
:return:
"""
conn_address = '127.11.2.9'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, conn_address, True, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
L2tpv3GlobalSettings.MustAvpsCheck = False
local_addr = '127.11.2.11'
conn = L2tpConnection(10, 10, conn_address, local_addr)
# Receive a good SCCCN, return NULL
avp1 = ControlMessageAVP(ControlMessageAVP.SCCCN)
avp2 = AssignedControlConnectionID(10)
avps = [avp1, avp2]
scccn = L2tpv3ControlPacket(0x1234, 0, 1, avps)
ret = conn.HandlePkt(scccn)
self.assertIsNotNone(ret)
self.assertIsInstance(ret, L2tpv3ACK)
# Receive a bad SCCCN, return stopCCN
session = L2tpv3Session(1, 2, 'receive', conn)
conn.addSession(session)
localSessionID = session.remoteSessionId
localAvp = LocalSessionID(localSessionID)
avp3 = CallSerialNumber()
avps.append(localAvp)
avps.append(avp3)
scccn = L2tpv3ControlPacket(0x1234, 0, 1, avps)
ret = conn.HandlePkt(scccn)
self.assertIsNotNone(ret)
self.assertIsInstance(ret, L2tpv3ACK)
# Recovery tunnel receive SCCCN
recover_conn = L2tpConnection(100, 100, conn_address, local_addr)
recover_conn.isInRecovery = True
conn.recoverConnection = recover_conn
conn.isRecoveryTunnel = True
avp1 = ControlMessageAVP(ControlMessageAVP.SCCCN)
avp2 = AssignedControlConnectionID(10)
avps = [avp1, avp2]
scccn = L2tpv3ControlPacket(0x1234, 0, 1, avps)
ret = conn.HandlePkt(scccn)
self.assertFalse(recover_conn.isInRecovery)
conn.CloseConnection()
