def start(self, setup=None): self._setup = setup if setup is None: return self._start_master() self.log.info('%s poller starting', setup) if setup == '[dummy]': return try: session.loadSetup(setup, allow_startupcode=False) for devname in session.getSetupInfo()[setup]['devices']: if devname in self.blacklist: self.log.debug('not polling %s, it is blacklisted', devname) continue # import the device class in the main thread; this is necessary # for some external modules like Epics self.log.debug('importing device class for %s', devname) try: session.importDevice(devname) except Exception: self.log.warning( '%-10s: error importing device class, ' 'not retrying this device', devname, exc=True) continue self.log.debug('starting thread for %s', devname) queue = Queue.Queue() worker = createThread('%s poller' % devname, self._worker_thread, args=(devname, queue)) worker.queue = queue self._workers[devname.lower()] = worker # start staggered to not poll all devs at once.... # use just a small delay, exact value does not matter sleep(0.0719) session.cache.addPrefixCallback('poller', self.enqueue_params_poll) except ConfigurationError as err: self.log.warning('Setup %r has failed to load!', setup) self.log.error(err, exc=True) self.log.warning('Not polling any devices!') # start a thread checking for modification of the setup file createThread('refresh checker', self._checker, args=(setup, )) self.log.info('%s poller startup complete', setup)
def session(request): """Test session fixture""" nicos_session.__class__ = TestSession nicos_session.__init__(request.module.__name__) # override the sessionid: test module, and a finer resolved timestamp nicos_session.sessionid = '%s-%s' % (request.module.__name__, time.time()) nicos_session.setMode(getattr(request.module, 'session_mode', MASTER)) if request.module.session_setup: nicos_session.unloadSetup() nicos_session.loadSetup( request.module.session_setup, **getattr(request.module, 'session_load_kw', {})) if getattr(request.module, 'session_spmode', False): nicos_session.setSPMode(True) yield nicos_session nicos_session.setSPMode(False) nicos_session.shutdown()
def NewSetup(*setupnames): """Load the given setups instead of the current one. Example: >>> NewSetup('tas', 'psd') will clear the current setup and load the "tas" and "psd" setups at the same time. Without arguments, the current setups are reloaded. Example: >>> NewSetup() You can use `ListSetups()` to find out which setups are available. see also: `AddSetup`, `RemoveSetup`, `ListSetups` """ current_mode = session.mode # reload current setups if none given update_aliases = True if not setupnames: update_aliases = False setupnames = session.explicit_setups # refresh setup files first session.readSetups() session.checkSetupCompatibility(setupnames, set()) session.unloadSetup() try: session.startMultiCreate() try: session.loadSetup(setupnames, update_aliases=update_aliases) finally: session.endMultiCreate() except Exception: session.log.warning( 'could not load new setup, falling back to ' 'startup setup', exc=1) session.unloadSetup() session.loadSetup('startup') if current_mode == MASTER: # need to refresh master status session.setMode(MASTER)
def AddSetup(*setupnames): """Load the given setups additional to the current one. Example: >>> AddSetup('gaussmeter') will load the "gaussmeter" setup in addition to the current setups. You can use `ListSetups()` to find out which setups are available. see also: `NewSetup`, `RemoveSetup`, `ListSetups` """ if not setupnames: ListSetups() return session.readSetups() session.checkSetupCompatibility(setupnames, session.loaded_setups) session.startMultiCreate() try: session.loadSetup(setupnames) finally: session.endMultiCreate()
def _get_maindev(cls, appname, maindevname, setupname): session.loadSetup(setupname or appname, allow_special=True, raise_failed=True, autoload_system=False) return session.getDevice(maindevname or appname.capitalize())
def run(cls, sock, uuid, setups, user, code, quiet=False, debug=False): session.__class__ = cls session._is_sandboxed = sock.startswith('ipc://') session._debug_log = debug socket = nicos_zmq_ctx.socket(zmq.DEALER) socket.connect(sock) # we either get an empty message (retrieve cache data ourselves) # or a pickled key-value database data = socket.recv() db = pickle.loads(data) if data else None # send log messages back to daemon if requested session.log_sender = SimLogSender(socket, session, uuid, quiet) username, level = user.rsplit(',', 1) session._user = User(username, int(level)) try: session.__init__(SIMULATION) except Exception as err: try: session.log.exception('Fatal error while initializing') finally: print('Fatal error while initializing:', err, file=sys.stderr) return 1 # Give a sign of life and then tell the log handler to only log # errors during setup. session.log.info('setting up dry run...') session.begin_setup() # Handle "print" statements in the script. sys.stdout = LoggingStdout(sys.stdout) try: # Initialize the session in simulation mode. session._mode = SIMULATION # Load the setups from the original system, this should give the # information about the cache address. session.log.info('loading simulation mode setups: %s', ', '.join(setups)) session.loadSetup(setups, allow_startupcode=False) # Synchronize setups and cache values. session.log.info('synchronizing to master session') session.simulationSync(db) # Set session to always abort on errors. session.experiment.errorbehavior = 'abort' except: # really *all* exceptions -- pylint: disable=W0702 session.log.exception('Exception in dry run setup') session.log_sender.finish() session.shutdown() return 1 # Set up log handlers to output everything. session.log_sender.begin_exec() # Execute the script code. exception = False try: last_clock = session.clock.time code, _ = parseScript(code) for i, c in enumerate(code): exec_(c, session.namespace) time = session.clock.time - last_clock last_clock = session.clock.time session.log_sender.send_block_result(i, time) except Abort: session.log.info('Dry run finished by abort()') except: # pylint: disable=W0702 session.log.exception('Exception in dry run') exception = True else: session.log.info('Dry run finished') finally: session.log_sender.finish(exception) # Shut down. session.shutdown()