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 setUp(self): setup_logging(("PROVISION", "DHCP"), filename="provision_dhcp.log") self.agent = DhcpAgent(simulate_mode=True) self.agent.ccap_cores['CORE-1234567890'] = { "mgr": "MGR-1234567890", } self.agent.dhcp['eth0'] = { "status": self.agent.DOWN, "requester": [ 'CORE-1234567890', ], "lastChangeTime": 1, "transport": self.agent.process_transport, "initiated_by": None, "initiated": False, } path = "ipc:///tmp/rcp.sock" transport = Transport(path, Transport.PUSHSOCK, Transport.TRANSPORT_CLIENT) # Add the fsm to our internal database self.agent.mgrs["MGR-1234567890"] = { "transport": transport, "name": "DHCP", "para": {}, "path": path, } # init agent dhcpv6 process self.agent.start_dhcpv6('eth0')
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_rpd_logging(self): # os.system('export LOG_PATH=/tmp/log_test') os.environ['LOG_PATH'] = '/tmp/log_test' self.logger.critical(os.getenv('LOG_PATH')) setup_logging("HAL", filename="test.log", env_key='LOG_PATH') if os.path.exists('/tmp/log_test'): os.remove('/tmp/log_test')
def setUp(self): create_db_conf() start_redis() RCPDB.DB_CFG_FILE = CONF_FILE setup_logging(("PROVISION", "GCP"), filename="provision_rcp.log") self.agent = RcpOverGcp() self.agent.ccap_cores['CORE-1234567890'] = {"mgr": "MGR-1234567890", } self.agent.rcp[('eth0', '1.1.1.1')] = { "status": self.agent.DOWN, "requester": ['CORE-1234567890', ], "lastChangeTime": 1, } path = "ipc:///tmp/rcp.sock" transport = Transport( path, Transport.PUSHSOCK, Transport.TRANSPORT_CLIENT) # Add the fsm to our internal database self.agent.mgrs["MGR-1234567890"] = { "transport": transport, "name": "RCP", "para": {}, "path": path, } seq = RCPSequence(gcp_msg_def.DataStructREQ, rcp_tlv_def.RCP_MSG_TYPE_REX, 1, rcp_tlv_def.RCP_OPERATION_TYPE_READ, unittest=True) self.agent.rcp_req_group[(1, '1.1.1.1')] = (seq, None, 'transaction_identifier', 'trans_id', time.time() - 5)
def setUp(self): self.connection = "" self.dispatcher = "" self.LocalAddr = "127.0.0.1" # self.LocalAddrList = {"127.0.0.2"} # self.remoteAddrList = {"127.0.0.1","127.0.0.2"} self.remoteAddrList = {"127.0.0.2"} setup_logging('L2TP')
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 demoDrvmain(): print "demoDrvmain thread start!" setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG) drv_logger = logging.getLogger("DrvMain") drv_logger.info("hello demo DrvMain Log") driver = OpenRpdDriver("openrpd_generic_driver", "This is a Generic OpenRPD Driver", "1.0.0", (0, 10000), (2, 3, 4)) driver.start() print "demoDrvmain thread done!"
def setUpClass(cls): setup_logging("L2TP") setup_test_redis() # Construct the API transport path ApiPath = L2tpv3GlobalSettings.L2tpv3GlobalSettings.APITransportPath print ApiPath cls.api = L2tpv3API(ApiPath) for key in Mcast.McastDb.keys(): Mcast.McastDb[key].close()
def demoDrvmain(): print "demoDrvmain thread start!" setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG) drv_logger = logging.getLogger("DrvMain") drv_logger.info("hello demo DrvMain Log") interestedNotification = list() interestedNotification.append(MsgTypeVspAvpExchange) driver = OpenRpdDriver("openrpd_generic_driver", "This is a Generic OpenRPD Driver", "1.0.0", tuple((0, 5000)), (2, 3, 4), interestedNotification) driver.start() print "demoDrvmain thread done!"
def setUpClass(cls): # open logger setup_logging("L2TP") setup_test_redis() cls.conn_address = '127.0.0.1' global_dispatcher = Dispatcher() dispatcher = L2tpv3Dispatcher( global_dispatcher, cls.conn_address, False, None) L2tpv3GlobalSettings.Dispatcher = dispatcher # setup the halclient notification_list = list() notification_list.append( HalConfigMsg.MsgTypeL2tpv3SessionStatusNotification) cls.hal_client = L2tpHalClient("L2TP_HAL_CLIENT", "the HAL client of L2TP feature", "1.0", tuple(L2tpHalClient.notification_list.keys()), global_dispatcher) cls.hal_client.handler = dispatcher.receive_hal_message cls.conn = L2tpConnection( 6661, 6662, cls.conn_address, cls.conn_address) cls.session = L2tpv3Session(6661, 6662, 'receiver', cls.conn) cls.conn.addSession(cls.session) localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(6661) remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(6662) remoteEnd = L2tpv3RFC3931AVPs.RemoteEndID( (((0, 3, 0), 0), ((0, 3, 1), 1), ((0, 3, 2), 2))) remoteEnd_1 = L2tpv3RFC3931AVPs.RemoteEndID( (((0, 3, 3), 3), ((0, 3, 4), 4), ((0, 3, 5), 5))) pw_type = L2tpv3RFC3931AVPs.L2SpecificSublayer(3) DepiL2SpecificSublayerSubtype = L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype(3) LocalMTUCableLabs = L2tpv3CableLabsAvps.LocalMTUCableLabs(1500) DepiRemoteMulticastJoin = L2tpv3CableLabsAvps.DepiRemoteMulticastJoin(("5.5.5.1", "229.1.1.255")) DepiResourceAllocReq = L2tpv3CableLabsAvps.DepiResourceAllocReq(((0, 1), (1, 2))) UpstreamFlow = L2tpv3CableLabsAvps.UpstreamFlow(((0, 1), (1, 2))) cls.session.avps_icrq.append(localSessionId) cls.session.avps_icrq.append(remoteSessionId) cls.session.avps_icrq.append(remoteEnd) cls.session.avps_icrq.append(remoteEnd_1) cls.session.avps_icrq.append(DepiL2SpecificSublayerSubtype) cls.session.avps_icrq.append(LocalMTUCableLabs) cls.session.avps_icrq.append(pw_type) cls.session.avps_icrq.append(DepiRemoteMulticastJoin) cls.session.avps_icrq.append(DepiResourceAllocReq) cls.session.avps_icrq.append(UpstreamFlow)
def setUpClass(cls): setup_logging("GCPP Unit test") setup_test_redis() cls.fwdCfg = StaticL2tpProvision() cls.ApiPath = \ L2tpv3GlobalSettings.L2tpv3GlobalSettings.APITransportPath cls.api = L2tpv3API(cls.ApiPath) global_dispatcher = Dispatcher() cls.hal_client = L2tpHalClient("L2TP_HAL_CLIENT", "the HAL client of L2TP feature", "1.0", tuple( L2tpHalClient.notification_list.keys()), global_dispatcher) cls.hal_client.pushSock = HalTransport( HalTransport.HalTransportClientAgentPull, HalTransport.HalClientMode, index=19, socketMode=HalTransport.HalSocketPushMode, disconnectHandlerCb=None)
def demoHalmain(): print "demoHalmain thread start!" HalGlobal.StopHal = False setup_logging('HAL', filename="hal.log") HalMain.logger = logging.getLogger("HalMain") HalMain.logger.info("hello demo HalMain Log") HalGlobal.gDispatcher = HalDispatcher() HalMain._mainLoop() print "clear Manager status!" keys = HalGlobal.gClientDB.keys() for clientId in keys: HalGlobal.gClientMgr.disconnectCb( HalGlobal.gClientDB[clientId]['agent']) if HalGlobalStats.NrClient != 0: raise Exception( "Cannot destroy the hal Main, reason: clients is not cleared") HalGlobal.StopHal = False print "demoHalmain thread done!"
def __init__(self, gpb_msg_class): """Creates dispatcher if not passed and initializes instance. TODO params dont match :param gpb_msg_class: A class of GPB messages which will be exchanged. :param rx_cb: User's RX callback which is called when some GPB message was received. The callback expects the GPB message as argument. :param disp: Dispatcher. New dispatcher is created if None is passed. """ if None is gpb_msg_class: raise AttributeError("No any GPB message class passed") if gpb_msg_class not in (t_ItApiRpdMessage, t_ItApiServiceSuiteMessage): raise AttributeError("Invalid GPB message class passed") self.gpb_msg_class = gpb_msg_class self.it_api_socket = None setup_logging("ItManager", filename="IT.log")
def setUpClass(cls): cls.logger.info("start setup...") cls.logger.info("************************************************") cls.logger.info("*** setUpClass: ***") cls.logger.info("************************************************") # open logger setup_logging("L2TP") # use the localhost as the default IP address global_dispatcher = Dispatcher() dispatcher = L2tpv3Dispatcher( global_dispatcher, L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress, create_global_listen=False) cls.dispatcher = L2tpv3GlobalSettings.L2tpv3GlobalSettings.Dispatcher = dispatcher # create the connection cls.connection = L2tpv3Connection.L2tpConnection( 666, 666, L2tpv3GlobalSettings.L2tpv3GlobalSettings.LocalIPAddress) # instance the transport cls.transport = cls.connection.transport
def __init__(self, gpb_msg_class, rx_cb, disp=None): """Opens socket on the IT API port and listen for GPB messages. :param gpb_msg_class: A class of GPB messages which will be exchanged. :param rx_cb: User's RX callback which is called when some GPB message was received. The callback expects the GPB message as argument. :param disp: Dispatcher. New dispatcher is created if None is passed. """ if None is gpb_msg_class: raise AttributeError("No GPB message class specified") if gpb_msg_class not in [ t_ItApiRpdMessage, t_ItApiServiceSuiteMessage ]: raise AttributeError("Unknown GPB message class passed") if None is rx_cb: raise AttributeError("No rx_cb specified") if None is disp: self.disp = dispatcher.Dispatcher() else: self.disp = disp self.rx_cb = rx_cb self.gpb_msg_class = gpb_msg_class setup_logging("ItManager", filename="IT.log") ctx = zmq.Context.instance() self.it_api_socket = ctx.socket(zmq.REP) self.it_api_socket.bind("tcp://*:{}".format(DEFAULT_IT_API_PORT)) self.disp.fd_register(self.it_api_socket.getsockopt(zmq.FD), self.disp.EV_FD_IN, self._it_api_socket_handler) self.logger.debug("Listening for testing requests")
def setUpClass(cls): setup_logging("PROVISION", filename="provision_mgr_process.log")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event) print 'Redundant core Delete' # standby core mode active caps = { "ActiveCoreIpAddress": '1.1.1.10', "StandbyCoreIpAddress": '1.1.1.5', 'interface': 'eth0', "operation": 1 } ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps)) mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event) # standby core mode standby caps = { "ActiveCoreIpAddress": '1.1.1.10', "StandbyCoreIpAddress": '1.1.1.5', 'interface': 'eth0', "operation": 1 } ccap_core[0].is_active = CoreDescription.CORE_MODE_STANDBY event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps)) mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event) mgr.fsm.Error(msg='test fsm error') if __name__ == '__main__': unittest.main() setup_logging("PROVISION", "test.log")
except Exception as exception: logger.error("Unexpected failure (%s): %s", type(exception), exception) exit(EX_OSERR) def handle_interrrupt_signal(signum, frame): # pragma: no cover sys.exit(0) def set_test_res_db(): # Setting the python path currentPath = path.dirname(path.realpath(__file__)) dirs = currentPath.split("/") rpd_index = dirs.index('rpd') if rpd_index == 0: print "Cannot find the rpd directory, please correct it" sys.exit(-1) RCPDB.DB_CFG_FILE = '/'.join( dirs[:rpd_index + 1]) + '/confdb/rpd_res_db.conf' # register the ctrl C to handle this signal if __name__ == "__main__": # pragma: no cover signal.signal(signal.SIGINT, handle_interrrupt_signal) # setup logging, will search the config files setup_logging("GCP", filename="rcp.log") main()
def setUpClass(cls): setupDB() time.sleep(2) HalGlobal.gClientMgr = None HalGlobal.gPoller = None t = threading.Thread(target=demoHalmain) t.daemon = True t.start() time.sleep(2) threads_list.append(t) if not HalGlobal.gClientMgr or not HalGlobal.gPoller: raise Exception("Cannot start the demo halMain") t = threading.Thread(target=demoL2tp) t.daemon = True t.start() time.sleep(2) threads_list.append(t) t = threading.Thread(target=demoDrvmain) t.daemon = True t.start() threads_list.append(t) time.sleep(2) setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG) cls.logger = logging.getLogger("L2tpHalDrvVspAvpTest") cls.logger.info("hello L2tpHalDrvVspAvpTest Log") cls.stop = False cls.conn_address = '127.0.0.1' # Setup connection/session: set it here since global variables are already only after threads are up. cls.dispatcher = L2tpv3GlobalSettings.Dispatcher cls.hal_client = L2tpv3GlobalSettings.l2tp_hal_client # cls.conn = L2tpConnection.L2tpConnection( # 6661, 6662, cls.conn_address, cls.conn_address) #cls.session = L2tpv3Session.L2tpv3Session(6661, 6662, 'receiver',cls.conn) # cls.conn.addSession(cls.session) localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(6661) remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(6662) remoteEnd = L2tpv3RFC3931AVPs.RemoteEndID( (((0, 3, 0), 0), ((0, 3, 1), 1), ((0, 3, 2), 2))) remoteEnd_1 = L2tpv3RFC3931AVPs.RemoteEndID( (((0, 3, 3), 3), ((0, 3, 4), 4), ((0, 3, 5), 5))) pw_type = L2tpv3RFC3931AVPs.L2SpecificSublayer(3) DepiL2SpecificSublayerSubtype = L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype( 3) LocalMTUCableLabs = L2tpv3CableLabsAvps.LocalMTUCableLabs(1500) cls.avps_icrq = [] cls.avps_icrq.append(localSessionId) cls.avps_icrq.append(remoteSessionId) cls.avps_icrq.append(remoteEnd) cls.avps_icrq.append(remoteEnd_1) cls.avps_icrq.append(DepiL2SpecificSublayerSubtype) cls.avps_icrq.append(LocalMTUCableLabs) cls.avps_icrq.append(pw_type) cls.icrq_buf = struct.pack( '!206B', 0xc8, 0x03, 0x0, 206, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x4, 0xc, 8, 0x0, 0x0, 0x0, 0x0, 0x0, 10, 0xc, 10, 0x0, 0x0, 0, 15, 0, 0, 0, 0, 0xc, 10, 0x0, 0x0, 0, 63, 0x40, 0x01, 0x00, 0x01, 0xc, 10, 0x0, 0x0, 0, 64, 0x0, 0x0, 0x0, 0x0, 0xc, 40, 0x0, 0x0, 0x0, 66, 0x0, 0x0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x03, 0x02, 0x02, 0x00, 0x03, 0x03, 0x03, 0x00, 0x03, 0x04, 0x04, 0x00, 0x03, 0x05, 0x05, 0x00, 0x03, 0x06, 0x06, 0x00, 0x03, 0x07, 0x07, 0xc, 8, 0, 0, 0, 68, 0, 12, 0xc, 8, 0, 0, 0, 69, 0, 3, 0xc, 8, 0, 0, 0, 71, 0, 2, 0xc, 8, 0x11, 0x8b, 0x0, 0x2, 0x1, 0x0, 0xc, 8, 0x11, 0x8b, 0x0, 0x4, 0x7, 0xD0, 0xc, 20, 0x11, 0x8b, 0x0, 15, 0x0, 0x1, 0x0, 0x2, 0x0, 0x3, 0x0, 0x6, 0x0, 0x8, 0x0, 11, 0x0, 13, 0xc, 8, 0x11, 0x8b, 0x0, 16, 0x0, 0x3, 0xc, 8, 0x11, 0x8b, 0x0, 17, 0x0, 0x3, 0xc, 40, 0x11, 0x8b, 0x0, 11, 0, 0, 0x5, 0x6, 0x7, 0x8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 229, 1, 1, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, )
def setUpClass(cls): setup_logging("PROVISION", "test.log") cls.mgr = ManagerProcess(simulator=True, test_flag=True)
"""setup cli.""" cli_db = redis.StrictRedis(unix_socket_path=db_defs.UNIX_SOCKET_PATH, db=db_defs.CLI_DB) while True: try: cli_db.exists(db_defs.ENABLE_PWD) break except redis.exceptions.ConnectionError: time.sleep(1) continue cli = CmdRpd(conf_file) allow = cli.authenticate() if allow: BasicCli(cli) SsdCli(cli) GcpCli(cli) ProvisionCli(cli) Ikev2Cli(cli) MacsecCli(cli) L2tpCli(cli) cli.cmdloop(cli.intro) if __name__ == '__main__': # setup the logging. setup_logging("CLI", "cli.log") cli = RPDCLI() cli.create_cli(DEF_CONF_FILE_NAME)
def main(): """Everything starts here.""" global logger parser = argparse.ArgumentParser("Hal args parser") parser.add_argument("--conf", metavar='C', type=str, help="Hal configuration path") args = parser.parse_args() config = _parseConfiguraion(args.conf) if config is None: sys.stderr.write( "Cannot load the configuration or the configuration format is not correct" ) sys.exit(-1) # setup the log setup_logging('HAL', filename="hal.log") # setup the logger logger = logging.getLogger("HalMain") # setup the Dispatcher HalGlobal.gDispatcher = HalDispatcher() # setup the database if "db" not in config: sys.stderr.write( "Cannot find the redis config information, using the default configuration" ) HalGlobal.gHalMsgDbConnection = HalDatabase("/tmp/redis.sock", 30, 12) HalGlobal.gHalClientDbConnection = HalDatabase("/tmp/redis.sock", 30, 11) else: dbConf = config["db"] logger.info( "Setting up the Hal database:\n\tPath:%s\n\tmsgDB:%d\n\tindexDB:%d" % (dbConf["address"], dbConf["msgDB"], dbConf["indexDB"])) HalGlobal.gHalMsgDbConnection = HalDatabase(dbConf["address"], dbConf["timeout"], dbConf["msgDB"]) HalGlobal.gHalClientDbConnection = HalDatabase(dbConf["address"], dbConf["timeout"], dbConf["indexDB"]) # Getting the un-handled message from the DB, we don't need to clean up # the DB since we have set the expire for keys if not HalGlobal.gHalMsgDbConnection.isDatabaseEmpty(): logger.info("Start to load all the resend messages to runtime memory") msgs = HalGlobal.gHalMsgDbConnection.listAllMsgs() for msg in msgs: logger.info("Loading message %s" % msg["Key"]) key = msg["Key"] gpbMsg = msg["Msg"] try: HalMsg = HalMessage.DeSerialize(gpbMsg) logger.debug("Got a zmq msg:%s" % HalMsg.msg) HalGlobal.gRestartResendMsg[key] = HalMsg except Exception as e: logger.error("Error happened when handling msg, error info:%s", str(e)) # get all the contents and put it in gClientIndex if not HalGlobal.gHalClientDbConnection.isDatabaseEmpty("ClientIndex"): logger.info( "Start to getting previous registered client ID and index... ") msgs = HalGlobal.gHalClientDbConnection.listAllMsgs("ClientIndex") for key in msgs: HalGlobal.gClientIndex[key] = msgs[key] _mainLoop()
rcp_message_id=rcp_tlv_def.RCP_MSG_TYPE_IRA, rcp_operation=operation) self.orch.add_data_to_send(data) print msg self.socket.send("") except Exception as e: MasterAPI.logger.error("") print "Error happnens when handle message:" + str(e) if __name__ == "__main__": # setup logging, will search the config files setup_logging("MasterSim", filename="rcp_master_sim.log") set_test_res_db() redis = start_redis() time.sleep(2) scale_test_packets = 1 send_no_wait = False arg_send_no_wait = '--no_wait' arg_pkt_count = '--pkt_count' arg_use_interface = '--use_interface' arg_ipv6 = "--ipv6" identification_file = "/conf/conf_core_identification_v4.json" i07_file = "/conf/I07Field_v4.json" if sys.argv[-1] != "--help" and sys.argv[-1] != arg_ipv6:
led_msg = t_LED() led_msg.setLed.ledType = led_msg.LED_TYPE_STATUS led_msg.setLed.color = led_msg.LED_COLOR_GREEN if operational: led_msg.setLed.action = led_msg.LED_ACTION_LIT else: led_msg.setLed.action = led_msg.LED_ACTION_DARK self.logger.debug("Set led notification message: %s", led_msg) self.sendNotificationMsg(MsgTypeSetLed, led_msg.SerializeToString()) class manager(object): def __init__(self): self.desc = "This is a test manager." if __name__ == "__main__": setup_logging('HAL', filename="provmgr_hal.log") dispatcher = Dispatcher() mgr = manager() haldriver = ProvMgrHalDriver("ProvMgr_HAL_CLIENT", "This is provision manager hal driver", "1.0.0", ProvMgrHalDriver.cfgmsg_list, ProvMgrHalDriver.ntfmsg_list, ProvMgrHalDriver.ntfmsg_list, dispatcher=dispatcher, mgr=mgr) haldriver.start() dispatcher.loop()
# Cable Television Laboratories, Inc. ("CableLabs") # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from rpd.provision.process_agent.agent.fake_agent import FakeAgent import rpd.provision.process_agent.agent.agent as agent from rpd.common.rpd_logging import setup_logging, AddLoggerToClass class PTP(FakeAgent): __metaclass__ = AddLoggerToClass def __init__(self): super(PTP, self).__init__(agent.ProcessAgent.AGENTTYPE_PTP) if __name__ == "__main__": setup_logging("PROVISION", filename="provision_ptp.log") pagent = PTP() pagent.start()
self.send_cfg_rsp_msg(cfg) except Exception as e: self.logger.error("Got an error:%s, the cfg msg:%s", str(e), cfg.msg) def cleanup_sockets(self): for fd in self.fd_to_socket: sock = self.fd_to_socket[fd] self.poller.unregister(sock) sock.close() self.fd_to_socket.clear() def handle_interrupt_signal(signum, frame): sys.exit(0) if __name__ == "__main__": setup_logging('HAL', filename="open_rpd_drv.log") signal.signal(signal.SIGINT, handle_interrupt_signal) driver = OpenRpdDriver("openrpd_generic_driver", "This is a Generic OpenRPD Driver", "1.0.0", (OpenRpdMsgHandler.default_supported_msg_types), (2, 3, 4)) # test_cfg = HalMessage("HalConfigRsp") # test_cfg.msg.SeqNum = 123456 # test_cfg.msg.Rsp.Status = HalCommon_pb2.SUCCESS # cfgMsg = capabilities_get(test_cfg) # driver.send_cfg_rsp_msg(cfgMsg) driver.start()
def test_verify_negative(self): print "\n===================================================" print "Begin to test the negative value verify....." print "===================================================" initcode = { "manufacturer": { "organizationName": "cisco", "codeAccessStart": "20160311122430Z", "cvcAccessStart": "20160311122430Z" }, "co-signer": { "organizationName": "comcast", "codeAccessStart": "20160311122430Z", "cvcAccessStart": "20160311122430Z" } } test = CFV(initcode, self.rootca) rst = test.verify_cvc('0000000000000000000000000000000', True) print "manufacturer CVC verification result: " + str( rst[0]) + ", " + RST.ssdErrorMessage[rst[1]] rst = test.verify_file('000000000000000000000000000000') print "codefile verification result: " + str( rst[0]) + ", " + RST.ssdErrorMessage[rst[1]] if __name__ == '__main__': setup_logging('HAL', filename="codefile_verifying.log") unittest.main()
def setUpClass(cls): setup_logging("L2TP") # Construct the API transport path cls.ApiPath = L2tpv3GlobalSettings.L2tpv3GlobalSettings.APITransportPath