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)