def close(self, avoidSave=False):
"""
Closing the configuration instance and free allocated resources.
:return:
"""
logger.internal("entering Configuration.close")
if not avoidSave:
ConfigFileLoader.saveGuiState(self)
Application.unactivate()
for sc in self._compositeFilters + self._applications:
sc.cleanup()
for c in self._compositeFilters:
self.subConfigRemoved.emit(c.getName(), self.CONFIG_TYPE_COMPOSITE)
self._compositeFilters = []
for a in self._applications:
self.subConfigRemoved.emit(a.getName(),
self.CONFIG_TYPE_APPLICATION)
self._applications = []
self._propertyCollection.deleteLater()
self._propertyCollection = PropertyCollectionImpl("root", None)
self.configNameChanged.emit(None)
self.appActivated.emit("", None)
PluginManager.singleton().unloadAll()
logger.internal("leaving Configuration.close")
def exception_setup(python, thread, where, activeTime_s):
logging.getLogger(__name__).info("------------------------------------------------------")
logging.getLogger(__name__).info("Starting exception_setup %d %s %s %f", python, thread, where, activeTime_s)
from nexxT.services.ConsoleLogger import ConsoleLogger
logger = ConsoleLogger()
Services.addService("Logging", logger)
class LogCollector(logging.StreamHandler):
def __init__(self):
super().__init__()
self.logs = []
def emit(self, record):
self.logs.append(record)
# avoid warning flood about service profiling not found
Services.addService("Profiling", None)
collector = LogCollector()
logging.getLogger().addHandler(collector)
try:
t = QTimer()
t.setSingleShot(True)
# timeout if test case hangs
t2 = QTimer()
t2.start((activeTime_s + 3)*1000)
try:
test_json = Path(__file__).parent / "test_except_constr.json"
with test_json.open("r", encoding='utf-8') as fp:
cfg = json.load(fp)
if nexxT.useCImpl and not python:
cfg["composite_filters"][0]["nodes"][2]["library"] = "binary://../binary/${NEXXT_PLATFORM}/${NEXXT_VARIANT}/test_plugins"
cfg["composite_filters"][0]["nodes"][2]["thread"] = thread
cfg["composite_filters"][0]["nodes"][2]["properties"]["whereToThrow"] = where
mod_json = Path(__file__).parent / "test_except_constr_tmp.json"
with mod_json.open("w", encoding="utf-8") as fp:
json.dump(cfg, fp)
config = Configuration()
ConfigFileLoader.load(config, mod_json)
config.activate("testApp")
app.processEvents()
aa = Application.activeApplication
init = True
def timeout():
nonlocal init
if init:
init = False
aa.stop()
aa.close()
aa.deinit()
else:
app.exit(0)
def timeout2():
print("Application timeout hit!")
nonlocal init
if init:
init = False
aa.stop()
aa.close()
aa.deinit()
else:
print("application exit!")
app.exit(1)
t2.timeout.connect(timeout2)
t.timeout.connect(timeout)
def state_changed(state):
if state == FilterState.ACTIVE:
t.setSingleShot(True)
t.start(activeTime_s*1000)
elif not init and state == FilterState.CONSTRUCTED:
t.start(1000)
aa.stateChanged.connect(state_changed)
aa.init()
aa.open()
aa.start()
app.exec_()
finally:
del t
del t2
finally:
logging.getLogger().removeHandler(collector)
Services.removeAll()
return collector.logs
def execute():
assertMainThread()
self._configuration.close()
logger.debug("Saving new config to %s", cfgFileName)
ConfigFileLoader.save(self._configuration, cfgFileName)
def execute():
assertMainThread()
logger.debug("Saving config file")
ConfigFileLoader.save(self._configuration, filename)
def execute():
assertMainThread()
logger.debug("Saving config file")
ConfigFileLoader.save(self._configuration, forceGuiState=True)
def execute():
assertMainThread()
ConfigFileLoader.load(self._configuration, cfgFileName)
def startNexT(cfgfile, active, execScripts, execCode, withGui):
"""
Starts next with the given config file and activates the given application.
:param cfgfile: path to config file
:param active: active application (if None, the first application in the config will be used)
:return: None
"""
logger.debug("Starting nexxT...")
config = Configuration()
lcl = QLocale.system()
lcl.setNumberOptions(QLocale.c().numberOptions())
QLocale.setDefault(lcl)
if withGui:
app = QApplication() if QApplication.instance() is None else QApplication.instance()
app.setWindowIcon(QIcon(":icons/nexxT.svg"))
app.setOrganizationName("nexxT")
app.setApplicationName("nexxT")
setupGuiServices(config)
else:
app = QCoreApplication() if QCoreApplication.instance() is None else QCoreApplication.instance()
app.setOrganizationName("nexxT")
app.setApplicationName("nexxT")
setupConsoleServices(config)
if cfgfile is not None:
ConfigFileLoader.load(config, cfgfile)
if withGui:
mainWindow = Services.getService("MainWindow")
mainWindow.restoreState()
mainWindow.show()
# the reference will still be held by the service, but here we don't need it anymore
del mainWindow
if active is not None:
config.activate(active)
# pylint: disable=unused-variable
# need to hold the reference of this until the method is called
i2 = MethodInvoker(dict(object=Application, method="initialize", thread=app.thread()),
MethodInvoker.IDLE_TASK) # pylint: disable=unused-variable
waitForSignal(config.appActivated)
if Application.activeApplication.getState() != FilterState.ACTIVE:
waitForSignal(Application.activeApplication.stateChanged, lambda s: s == FilterState.ACTIVE)
logger.info("done")
def cleanup():
logger.debug("cleaning up loaded services")
Services.removeAll()
logger.debug("cleaning up loaded plugins")
for v in ("last_traceback", "last_type", "last_value"):
if hasattr(sys, v):
del sys.__dict__[v]
#PluginManager.singleton().unloadAll()
logger.debug("cleaning up complete")
code_globals = {}
for c in execCode:
logger.info("Executing code '%s'", c)
# note that exec is used intentionally here to provide the user with scripting posibilities
exec(compile(c, "<string>", 'exec'), code_globals) # pylint: disable=exec-used
logger.debug("Executing code done")
for s in execScripts:
logger.info("Executing script '%s'", s)
with open(s) as fscript:
# note that exec is used intentionally here to provide the user with scripting possibilities
exec(compile(fscript.read(), s, 'exec'), code_globals) # pylint: disable=exec-used
logger.debug("Executing script done")
res = app.exec_()
logger.debug("closing config")
config.close()
cleanup()
logger.internal("app.exec_ returned")
return res
def simple_setup(activeTime_s):
t = QTimer()
t.setSingleShot(True)
# timeout if test case hangs
t2 = QTimer()
t2.start((activeTime_s + 3) * 1000)
try:
if nexxT.useCImpl:
test_json = Path(__file__).parent / "test2.json"
else:
test_json = Path(__file__).parent / "test1.json"
config = Configuration()
ConfigFileLoader.load(config, test_json)
# we don't have a save as feature yet, so this function is throwing an exception atm
expect_exception(ConfigFileLoader.save, config,
test_json.parent / "test1.saved.json")
config.activate("testApp")
app.processEvents()
aa = Application.activeApplication
init = True
def timeout():
nonlocal init
if init:
init = False
aa.stop()
aa.close()
aa.deinit()
else:
app.exit(0) #logging.INTERNAL = INTERNAL
def timeout2():
print("Application timeout hit!")
nonlocal init
if init:
init = False
aa.stop()
aa.close()
aa.deinit()
else:
app.exit(1)
t2.timeout.connect(timeout2)
t.timeout.connect(timeout)
def state_changed(state):
if state == FilterState.ACTIVE:
t.setSingleShot(True)
t.start(activeTime_s * 1000)
elif not init and state == FilterState.CONSTRUCTED:
t.start(1000)
aa.stateChanged.connect(state_changed)
aa.init()
aa.open()
aa.start()
app.exec_()
finally:
del t
del t2