class Initializer(Loggable):
"""
"""
pd = None
name = 'Initializer'
application = Any
device_prefs = Any
init_list = None
def __init__(self, *args, **kw):
super(Initializer, self).__init__(*args, **kw)
self.parser = InitializationParser()
self.init_list = []
def add_initialization(self, a):
"""
"""
self.debug('add initialization {}'.format(a))
self.init_list.append(a)
def run(self, application=None):
self.application = application
ok = True
self.info('Running Initializer')
nsteps = 1
for idict in self.init_list:
nsteps += self._get_nsteps(**idict)
pd = self._load_progress(nsteps)
for idict in self.init_list:
ok = self._run(**idict)
if not ok:
break
msg = ('Complete' if ok else 'Failed')
self.info('Initialization {}'.format(msg))
pd.close()
return ok
def info(self, msg, **kw):
pd = self.pd
if pd is not None:
offset = pd.get_value()
if offset == pd.max - 1:
pd.max += 1
pd.change_message(msg)
super(Initializer, self).info(msg, **kw)
def _run(self,
name=None,
device_dir=None,
manager=None,
plugin_name=None):
if device_dir is None:
device_dir = paths.device_dir
parser = self.parser
if manager is not None:
self.info('Manager loading {}'.format(name))
manager.application = self.application
manager.load()
else:
return False
managers = []
devices = []
flags = []
timed_flags = []
valve_flags_attrs = []
mp, name = self._get_plugin(name, plugin_name)
if mp is not None:
if not globalv.ignore_required:
if not self._check_required(mp):
return False
managers = parser.get_managers(mp)
devices = parser.get_devices(mp)
flags = parser.get_flags(mp)
timed_flags = parser.get_timed_flags(mp)
valve_flags = parser.get_valve_flags(mp, element=True)
if valve_flags:
for vf in valve_flags:
vs = vf.find('valves')
if vs:
vs = vs.split(',')
valve_flags_attrs.append((vf.text.strip(), vs))
# set rpc server
mode, _, port = parser.get_rpc_params(mp)
if port and mode != 'client':
manager.load_rpc_server(port)
if managers:
self.info('loading managers - {}'.format(', '.join(managers)))
manager.name = name
self._load_managers(manager, managers, device_dir)
if devices:
self.info('loading devices - {}'.format(', '.join(devices)))
self._load_devices(manager, name, devices, plugin_name)
if flags:
self.info('loading flags - {}'.format(', '.join(flags)))
self._load_flags(manager, flags)
if timed_flags:
self.info('loading timed flags - {}'.format(','.join(timed_flags)))
self._load_timed_flags(manager, timed_flags)
if valve_flags_attrs:
self.info('loading valve flags - {}'.format(','.join(valve_flags_attrs)))
self._load_valve_flags(manager, valve_flags_attrs)
if manager is not None:
self.info('finish {} loading'.format(name))
manager.finish_loading()
return True
def _load_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_flag(f)
def _load_timed_flags(self, manager, flags):
for f in flags:
self.info('loading {}'.format(f))
manager.add_timed_flag(f)
def _load_valve_flags(self, manager, flags):
for f, v in flags:
self.info('loading {}, valves={}'.format(f, v))
manager.add_valve_flag(f, v)
def _load_managers(self,
manager,
managers,
device_dir):
for mi in managers:
man = None
self.info('load {}'.format(mi))
mode, host, port = self.parser.get_rpc_params((mi, manager.name))
remote = mode == 'client'
try:
man = getattr(manager, mi)
if man is None:
man = manager.create_manager(mi, host=host,
port=port, remote=remote)
except AttributeError, e:
self.warning(e)
try:
man = manager.create_manager(mi,
host=host,
port=port, remote=remote)
except Exception:
import traceback
traceback.print_exc()
if man is None:
self.debug('trouble creating manager {}'.format(mi))
continue
if self.application is not None:
# register this manager as a service
man.application = self.application
self.application.register_service(type(man), man)
d = dict(name=mi, device_dir=device_dir, manager=man,
plugin_name=manager.name)
self.add_initialization(d)
