def _resolve_methods(self): from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in list(self._services.values()): for attr in dir(service): to_resolve.append(getattr(service, attr)) resolve_methods(self._schemas, to_resolve)
def _resolve_methods(self, services, events): from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in services: for attr in dir(service): method = getattr(service, attr) if not callable(method): continue to_resolve.append({ 'name': attr, 'type': 'method', 'keys': ['accepts', 'returns'], 'has_key': functools.partial(hasattr, method), 'get_attr': functools.partial(getattr, method), }) for name, attrs in events: to_resolve.append({ 'name': name, 'type': 'event', 'keys': ['accepts', 'returns'], 'has_key': lambda k: k in attrs, 'get_attr': functools.partial(dict.get, attrs), }) resolve_methods(self._schemas, to_resolve)
async def _call(self, name, serviceobj, method, args): to_resolve = [ getattr(serviceobj, attr) for attr in dir(serviceobj) if attr != 'query' ] resolve_methods(self.__schemas, to_resolve) return await method(*args)
def _load_plugins(self, on_module_begin=None, on_module_end=None, on_modules_loaded=None): from middlewared.service import Service, CompoundService, CRUDService, ConfigService, SystemServiceService services = [] main_plugins_dir = os.path.realpath( os.path.join( os.path.dirname(os.path.realpath(__file__)), '..', 'plugins', )) plugins_dirs = [ os.path.join(overlay_dir, 'plugins') for overlay_dir in self.overlay_dirs ] plugins_dirs.insert(0, main_plugins_dir) for plugins_dir in plugins_dirs: if not os.path.exists(plugins_dir): raise ValueError(f'plugins dir not found: {plugins_dir}') for mod in load_modules(plugins_dir, depth=1): if on_module_begin: on_module_begin(mod) services.extend( load_classes( mod, Service, (ConfigService, CRUDService, SystemServiceService))) if on_module_end: on_module_end(mod) key = lambda service: service._config.namespace for name, parts in itertools.groupby(sorted(set(services), key=key), key=key): parts = list(parts) if len(parts) == 1: service = parts[0](self) else: service = CompoundService(self, [part(self) for part in parts]) self.add_service(service) if on_modules_loaded: on_modules_loaded() # Now that all plugins have been loaded we can resolve all method params # to make sure every schema is patched and references match from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in list(self._services.values()): for attr in dir(service): to_resolve.append(getattr(service, attr)) resolve_methods(self._schemas, to_resolve)
async def __plugins_load(self): from middlewared.service import Service, CRUDService, ConfigService, SystemServiceService main_plugins_dir = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'plugins', ) plugins_dirs = [os.path.join(overlay_dir, 'plugins') for overlay_dir in self.overlay_dirs] plugins_dirs.insert(0, main_plugins_dir) self.logger.debug('Loading plugins from {0}'.format(','.join(plugins_dirs))) self._console_write(f'loading plugins') setup_funcs = [] for plugins_dir in plugins_dirs: if not os.path.exists(plugins_dir): raise ValueError(f'plugins dir not found: {plugins_dir}') for mod in load_modules(plugins_dir): self._console_write(f'loaded plugin {mod.__name__}') self.__incr_startup_seq() for cls in load_classes(mod, Service, (ConfigService, CRUDService, SystemServiceService)): self.add_service(cls(self)) if hasattr(mod, 'setup'): setup_funcs.append((mod.__name__.rsplit('.', 1)[-1], mod.setup)) self._console_write(f'resolving plugins schemas') # Now that all plugins have been loaded we can resolve all method params # to make sure every schema is patched and references match from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in list(self.__services.values()): for attr in dir(service): to_resolve.append(getattr(service, attr)) resolve_methods(self.__schemas, to_resolve) # Only call setup after all schemas have been resolved because # they can call methods with schemas defined. setup_total = len(setup_funcs) for i, setup_func in enumerate(setup_funcs): name, f = setup_func self._console_write(f'setting up plugins ({name}) [{i + 1}/{setup_total}]') self.__incr_startup_seq() call = f(self) # Allow setup to be a coroutine if asyncio.iscoroutinefunction(f): await call self.logger.debug('All plugins loaded')
def _load_plugins(self, on_module_begin=None, on_module_end=None, on_modules_loaded=None): from middlewared.service import Service, CRUDService, ConfigService, SystemServiceService main_plugins_dir = os.path.realpath( os.path.join( os.path.dirname(os.path.realpath(__file__)), '..', 'plugins', )) plugins_dirs = [ os.path.join(overlay_dir, 'plugins') for overlay_dir in self.overlay_dirs ] plugins_dirs.insert(0, main_plugins_dir) for plugins_dir in plugins_dirs: if not os.path.exists(plugins_dir): raise ValueError(f'plugins dir not found: {plugins_dir}') for mod in load_modules(plugins_dir): if on_module_begin: on_module_begin(mod) for cls in load_classes( mod, Service, (ConfigService, CRUDService, SystemServiceService)): self.add_service(cls(self)) if on_module_end: on_module_end(mod) if on_modules_loaded: on_modules_loaded() # Now that all plugins have been loaded we can resolve all method params # to make sure every schema is patched and references match from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in list(self._services.values()): for attr in dir(service): to_resolve.append(getattr(service, attr)) resolve_methods(self._schemas, to_resolve)
def _load_plugins(self, on_module_begin=None, on_module_end=None, on_modules_loaded=None): from middlewared.service import Service, CRUDService, ConfigService, SystemServiceService main_plugins_dir = os.path.realpath(os.path.join( os.path.dirname(os.path.realpath(__file__)), '..', 'plugins', )) plugins_dirs = [os.path.join(overlay_dir, 'plugins') for overlay_dir in self.overlay_dirs] plugins_dirs.insert(0, main_plugins_dir) for plugins_dir in plugins_dirs: if not os.path.exists(plugins_dir): raise ValueError(f'plugins dir not found: {plugins_dir}') for mod in load_modules(plugins_dir): if on_module_begin: on_module_begin(mod) for cls in load_classes(mod, Service, ( ConfigService, CRUDService, SystemServiceService) ): self.add_service(cls(self)) if on_module_end: on_module_end(mod) if on_modules_loaded: on_modules_loaded() # Now that all plugins have been loaded we can resolve all method params # to make sure every schema is patched and references match from middlewared.schema import resolve_methods # Lazy import so namespace match to_resolve = [] for service in list(self._services.values()): for attr in dir(service): to_resolve.append(getattr(service, attr)) resolve_methods(self._schemas, to_resolve)
async def _call(self, name, serviceobj, method, args): to_resolve = [getattr(serviceobj, attr) for attr in dir(serviceobj) if attr != 'query'] resolve_methods(self.__schemas, to_resolve) return await method(*args)