oVirt (Open Virtual) 之 VDSM 学习笔记 (二) 流程追踪

 1 def serve_clients(log):
 2     cif = None
 3     irs = None
 4     scheduler = None
 5     running = [True]
 6 
 7     def sigtermHandler(signum, frame):
 8         log.debug("Received signal %s" % signum)
 9         running[0] = False
10 
11     def sigusr1Handler(signum, frame):
12         if irs:
13             log.debug("Received signal %s" % signum)
14             irs.spmStop(
15                 irs.getConnectedStoragePoolsList()[‘poollist‘][0])
16 
17     sigutils.register()
18     signal.signal(signal.SIGTERM, sigtermHandler)
19     signal.signal(signal.SIGUSR1, sigusr1Handler)
20     zombiereaper.registerSignalHandler()
21 
22     profile.start()
23 
24     libvirtconnection.start_event_loop()
25 
26     try:
27         if config.getboolean(‘irs‘, ‘irs_enable‘):
28             try:
29                 irs = Dispatcher(HSM())
30             except:
31                 utils.panic("Error initializing IRS")
32 
33         from clientIF import clientIF  # must import after config is read
34         cif = clientIF.getInstance(irs, log)
35 
36         install_manhole({‘irs‘: irs, ‘cif‘: cif})
37 
38         scheduler = schedule.Scheduler(name="vdsm.Scheduler",
39                                        clock=utils.monotonic_time)
40         scheduler.start()
41         cif.start()
42         periodic.start(cif, scheduler)
43         try:
44             while running[0]:
45                 sigutils.wait_for_signal()
46 
47             profile.stop()
48         finally:
49             periodic.stop()
50             cif.prepareForShutdown()
51             scheduler.stop()
52     finally:
53         libvirtconnection.stop_event_loop(wait=False)

1 def start():
2     cpu.start()
3     memory.start()

 1 def start():
 2     """ Starts application wide CPU profiling """
 3     if is_enabled():
 4         _start_profiling(_CLOCK, _BUILTINS, _THREADS)
 5 
 6 
 7 
 8 def start():
 9     """ Starts application memory profiling """
10     if is_enabled():
11         _start_profiling()

 1 def start_event_loop():
 2     __event_loop.start()
 3 
 4 
 5 __event_loop = _EventLoop()
 6 
 7 
 8 class _EventLoop:
 9     def __init__(self):
10         self.run = False
11         self.__thread = None
12 
13     def start(self):
14         assert not self.run
15         self.__thread = threading.Thread(target=self.__run,
16                                          name="libvirtEventLoop")
17         self.__thread.setDaemon(True)
18         self.run = True
19         self.__thread.start()
20 
21     @utils.traceback(on=log.name)
22     def __run(self):
23         try:
24             libvirt.virEventRegisterDefaultImpl()
25             while self.run:
26                 libvirt.virEventRunDefaultImpl()
27         finally:
28             self.run = False

 1     def __init__(self):
 2         """
 3         The HSM Constructor
 4 
 5         :param defExcFunc: The function that will set the default exception
 6                            for this thread
 7         :type defExcFun: function
 8         """
 9         self._ready = False
10         rm.ResourceManager.getInstance().registerNamespace(
11             STORAGE, rm.SimpleResourceFactory())
12         self.storage_repository = config.get(‘irs‘, ‘repository‘)
13         self.taskMng = taskManager.TaskManager()
14 
15         mountBasePath = os.path.join(self.storage_repository,
16                                      sd.DOMAIN_MNT_POINT)
17         fileUtils.createdir(mountBasePath)
18         storageServer.MountConnection.setLocalPathBase(mountBasePath)
19         storageServer.LocalDirectoryConnection.setLocalPathBase(mountBasePath)
20         self._connectionAliasRegistrar = 21             storageServer.ConnectionAliasRegistrar(STORAGE_CONNECTION_DIR)
22         self._connectionMonitor = 23             storageServer.ConnectionMonitor(self._connectionAliasRegistrar)
24         self._connectionMonitor.startMonitoring()
25 
26         sp.StoragePool.cleanupMasterMount()
27         self.__releaseLocks()
28 
29         self._preparedVolumes = defaultdict(list)
30 
31         self.__validateLvmLockingType()
32 
33         oop.setDefaultImpl(config.get(‘irs‘, ‘oop_impl‘))
34 
35         # cleanStorageRepoitory uses tasksDir value, this must be assigned
36         # before calling it
37         self.tasksDir = config.get(‘irs‘, ‘hsm_tasks‘)
38 
39         # This part should be in same thread to prevent race on mounted path,
40         # otherwise, storageRefresh can unlink path that is used by another
41         # thread that was initiated in the same time and tried to use the
42         # same link.
43         try:
44             # This call won‘t get stuck if mount is inaccessible thanks to
45             # misc.walk, this sync call won‘t delay hsm initialization.
46             self.__cleanStorageRepository()
47         except Exception:
48             self.log.warn("Failed to clean Storage Repository.", exc_info=True)
49 
50         @utils.traceback(on=self.log.name)
51         def storageRefresh():
52             sdCache.refreshStorage()
53             lvm.bootstrap(refreshlvs=blockSD.SPECIAL_LVS)
54             self._ready = True
55             self.log.debug("HSM is ready")
56 
57         storageRefreshThread = threading.Thread(target=storageRefresh,
58                                                 name="storageRefresh")
59         storageRefreshThread.daemon = True
60         storageRefreshThread.start()
61 
62         monitorInterval = config.getint(‘irs‘, ‘sd_health_check_delay‘)
63         self.domainMonitor = monitor.DomainMonitor(monitorInterval)