def doInit(self, mode): if requests is None: raise ConfigurationError(self, 'requests package is missing') self._prefix = self.prefix.strip('/') if self._prefix: self._prefix += '/' self._initFilters() self._queue = queue.Queue(1000) self._processor = createThread('webhookprocessor', self._processQueue)
def _checkLimits(self, limits): # Called by doReadUserlimits and doWriteUserlimits low, high = self.abslimits if low == 0 and high == 0: # No limits defined in IOC. # Could be a rotation stage for example. return if limits[0] < low or limits[1] > high: raise ConfigurationError('cannot set user limits outside of ' 'absolute limits (%s, %s)' % (low, high))
def _name_server(self): tmp = self.config.split() if tmp[2].count(':') and not self.absdev: return tmp[2].split(':')[0] elif self.nameserver: return self.nameserver else: raise ConfigurationError( self, 'No name server configured. Please ' 'use the "nameserver" parameter or put it' 'into the "config" parameter.')
def configdata(name): from nicos.core.errors import ConfigurationError try: setupname, element = name.split('.') except ValueError: raise ConfigurationError('configdata() argument must be in the ' 'form \'module.valuename\'') from None if setupname not in all_setups: raise ConfigurationError('config setup "%s" not found' % setupname) else: fullname = all_setups[setupname] ns = {} with open(fullname, encoding='utf-8') as fp: exec(fp.read(), ns) dep_files.add(fullname) try: return ns[element] except KeyError: raise ConfigurationError('value named %s not found in config setup' ' "%s"' % (element, setupname)) from None
def doInit(self, mode): if mode == SIMULATION: return CARESSDevice.doInit(self, mode) if hasattr(self._caressObject, 'is_counting_module'): is_counting = \ self._caress_guard(self._caressObject.is_counting_module, self.cid) self.log.debug('counting module: %r', is_counting) if not is_counting: raise ConfigurationError(self, 'Object is not a measurable module')
def _checkLimits(self, limits): umin, umax = limits amin, amax = self.abslimits if isinstance(self, HasOffset): offset = getattr(self, '_new_offset', self.offset) umin += offset umax += offset else: offset = 0 if umin > umax: raise ConfigurationError( self, 'user minimum (%s, offset %s) above the user ' 'maximum (%s, offset %s)' % (umin, offset, umax, offset)) if umin < amin - abs(amin * 1e-12): raise ConfigurationError( self, 'user minimum (%s, offset %s) below the ' 'absolute minimum (%s)' % (umin, offset, amin)) if umax > amax + abs(amax * 1e-12): raise ConfigurationError( self, 'user maximum (%s, offset %s) above the ' 'absolute maximum (%s)' % (umax, offset, amax))
def __init__(self, parent, client, options): Panel.__init__(self, parent, client, options) self._error_window = None if 'uifile' not in options: raise ConfigurationError('GenericPanels require at least an' ' `uifile` option.') loadUi(self, findResource(options['uifile'])) if options.get('showmsg'): self.client.message.connect(self.on_client_message) if client.isconnected: self.on_client_connected() client.connected.connect(self.on_client_connected)
def subscribe(self, topic): """ Create the thread that provides call backs on new messages """ # Remove all the assigned topics self._consumer.unsubscribe() topics = self._consumer.topics() if topic not in topics: raise ConfigurationError('Provided topic %s does not exist' % topic) # Assign the partitions partitions = self._consumer.partitions_for_topic(topic) if not partitions: raise ConfigurationError('Cannot query partitions for %s' % topic) self._consumer.assign([kafka.TopicPartition(topic, p) for p in partitions]) self._stoprequest = False self._updater_thread = createThread('updater_' + topic, self._get_new_messages) self.log.debug('subscribed to updates from topic: %s' % topic)
def _initObject(self): if not self._orb: raise ProgrammingError(self, 'Programmer forgot to call _initORB') obj = self._orb.resolve_initial_references('NameService') _root_context = obj._narrow(CosNaming.NamingContext) if not _root_context: raise CommunicationError( self, 'Failed to narrow the root naming' ' context') if self._is_corba_device(): try: tmp = self.objname.split('.') if self.objname else \ self.config.split()[2].split('.') if len(tmp) < 2: tmp.append('caress_object') self.log.debug('%r', tmp) obj = _root_context.resolve( [CosNaming.NameComponent(tmp[0], tmp[1])]) except CosNaming.NamingContext.NotFound as ex: raise ConfigurationError(self, 'Name not found: %s' % (ex, )) from ex self._caressObject = obj._narrow(CARESS.CORBADevice) else: try: self._caressObject = \ self._orb.string_to_object('corbaname::%s#%s.context/' 'caress.context/' 'server.context/absdev.object' % (self.nameserver, self.objname)) except CORBA.BAD_PARAM as ex: raise ConfigurationError(self, 'Name not found: %s' % (ex, )) from ex if CORBA.is_nil(self._caressObject): raise CommunicationError(self, 'Could not create a CARESS device') if hasattr(self._caressObject, 'init_module_orb'): self._caressObject.init_module = self._caressObject.init_module_orb
def doInit(self, mode): KafkaCacheDatabase.doInit(self, mode) if self.historytopic not in self._consumer.topics(): raise ConfigurationError( 'Topic "%s" does not exist. Create this topic and restart.' % self.historytopic) # Create the history consumer self._history_consumer = KafkaConsumer(bootstrap_servers=self.brokers) # Give up if the topic does not exist if self.historytopic not in self._history_consumer.topics(): raise ConfigurationError( 'Topic "%s" does not exist. Create this topic and restart.' % self.historytopic) # Assign the partitions partitions = self._history_consumer.partitions_for_topic( self.historytopic) self._history_consumer.assign( [TopicPartition(self.historytopic, p) for p in partitions])
def doInit(self, _mode): self._pilatus_detectors = [] for det_name in self.detectors: if isinstance(session.getDevice(det_name), Detector): self._pilatus_detectors.append(session.getDevice(det_name)) else: self.log.warning('non-pilatus detector %r uses pilatus image ' 'file sink', det_name) if not self._pilatus_detectors: raise ConfigurationError( 'pilatus data sink requires at least one pilatus detector ' 'device that is an instance of {}'.format(Detector) )
def doInit(self, mode): CARESSDevice.doInit(self, mode) if session.sessiontype == POLLER or mode == SIMULATION: return self._setROParam('_started', False) is_readable = True if hasattr(self._caressObject, 'is_readable_module'): is_readable = self._caress_guard( self._caressObject.is_readable_module, self.cid) if hasattr(self._caressObject, 'is_drivable_module'): is_drivable = self._caress_guard( self._caressObject.is_drivable_module, self.cid) elif self._device_kind() in [CORBA_DEVICE, 501]: # 500, 501 devices may be any combination of readable or drivable # Query capabilities from server (ret, _, _, chtype) = self._caress_guard( self._caressObject.readblock_params_orb, -0x80000000, self.cid, 1, 0, 0) if ret != READBLOCK_NORMAL or chtype != CHTYPE_INT32: # Something went wrong, assume no capabilities is_readable = False is_drivable = False else: (ret, _, dataseq) = self._caress_guard( self._caressObject.int_readblock_module_orb, -0x80000000, self.cid, 1, 1, ()) if ret != READBLOCK_NORMAL or len(dataseq) != 1: # Something went wrong, assume no capabilities is_readable = False is_drivable = False else: is_readable = bool(dataseq[0] & DEVICE_READABLE) is_drivable = bool(dataseq[0] & DEVICE_DRIVABLE) # readable, drivable, counting, status, needs_reference, # new_interface else: is_drivable = self._device_kind() in [3, 7, 13, 14, 15, 23, 24, 25, 28, 29, 30, 31, 32, 33, 37, 39, 40, 41, 43, 44, 45, 49, 50, 51, 53, 54, 56, 62, 67, 68, 70, 71, 72, 73, 76, 100, 103, 105, 106, 107, 108, 110, 111, 112, 114, 115, 123, 124, 125, 126] self.log.debug('readable module: %r', is_readable) self.log.debug('driveable module: %r', is_drivable) if not (is_drivable or is_readable): raise ConfigurationError(self, 'Object is not a moveable module')
def __init__(self, parent, client, options): Panel.__init__(self, parent, client, options) loadUi(self, findResource('nicos_mlz/gui/tunewavetable.ui')) self._dev = options.get('tabledev') measuremode = options.get('measuremode', 'nrse') if measuremode not in ['nrse', 'mieze']: measuremode = 'nrse' for i in range(self.measModeComboBox.count()): if measuremode == self.measModeComboBox.itemText(i): self.measModeComboBox.setCurrentIndex(i) break # access to the echotime device if not self._dev: raise ConfigurationError('TuneWaveTable panel: At least `tabledev`' ' is required.') self._header_labels = [] self._available_tables = {} self._edit = None self._blocked_while_edit = [ self.measModeComboBox, self.wavelengthComboBox, self.restorePushButton, self.savePushButton, self.refreshPushButton, self.deletePushButton ] self.tableWidget.installEventFilter(self) self.tableWidget.verticalHeader().setContextMenuPolicy( Qt.CustomContextMenu) self.measModeComboBox.currentIndexChanged.connect(self._fill_table) self.measModeComboBox.currentIndexChanged.connect( self._update_combo_boxes) self.wavelengthComboBox.currentIndexChanged.connect(self._fill_table) self.savePushButton.clicked.connect(self._save_current_table) self.refreshPushButton.clicked.connect(self._update_available_tables) self.tableWidget.verticalHeader()\ .customContextMenuRequested.connect( self.on_tableWidget_customContextMenuRequested) self.tableWidget.cellActivated.connect(self._edit_cell) self.tableWidget.verticalHeader().sectionClicked.connect( self._stop_edit) self.tableWidget.horizontalHeader().sectionPressed.connect( self._stop_edit) self.tableWidget.setAlternatingRowColors(True) client.connected.connect(self.on_client_connected) client.device.connect(self.on_client_device) self._dev_available = False
def doStart(self, target): crystal = self._crystal(0) if not crystal: raise PositionError(self, 'Not valid setup') tthm = asin(target / (2 * self._d(0))) / pi * 360. plane = crystal.get(self.plane, None) if not plane: raise ConfigurationError(self, 'No valid mono configuration') omgm = tthm / 2.0 + plane[1] + plane[2] self.log.debug(self._attached_tthm, 'will be moved to %.3f' % tthm) self.log.debug(self._attached_omgm, 'will be moved to %.3f' % omgm) if self._attached_tthm.isAllowed(tthm) and \ self._attached_omgm.isAllowed(omgm): self._attached_tthm.start(tthm) self._attached_omgm.start(omgm)
def doInit(self, mode): if mode == SIMULATION: return if not omniORB: raise ConfigurationError(self, 'There is no CORBA module found') self._initORB( ['-ORBInitRef', 'NameService=corbaname::%s' % self._name_server()]) self._initObject() _cid = self._getCID(self.config.split(None, 2)[0]) self._init(_cid) if session.sessiontype != POLLER: # omniORB.setClientCallTimeout(self._caressObject, 0) self._setROParam('cid', _cid) if self._cache: self._cache.invalidate(self, 'cid')
def create(self, name, h5parent, sinkhandler): try: array = session.getDevice(self._array_name) if not isinstance(array, HistogramConfArray): raise ConfigurationError('%s is no HistogramConfArray' % self._array_name) except ConfigurationError: session.log.warning('Array %s not found, NOT stored', self._array_name) return dset = h5parent.create_dataset(name, tuple(array.dim), 'float32') if self._scale != 1.: dset[...] = np.array(array.data, dtype='float32') * self._scale else: dset[...] = array.data self.createAttributes(dset, sinkhandler)
def __init__(self, name, dtype, dims): shape = [] dimnames = [] dimunits = [] dimbins = [] for dim in dims: if not isinstance(dim, HistogramDimDesc): raise ConfigurationError('%s should be of type ' 'HistogramDimDesc' % dim) shape.append(dim.length) dimnames.append(dim.label) dimunits.append(dim.unit) dimbins.append(dim.bins) ArrayDesc.__init__(self, name, shape, dtype, dimnames) self.dimunits = dimunits self.dimbins = dimbins self.dimbins = dimbins
def registerDevice(self, device): if not self._secnode: raise IOError('unconnected') self.log.debug('register %s on %s' % (device, self)) self._devices[device.name] = device module = device.secop_module if module not in self._secnode.modules: raise ConfigurationError('no module %r found on this SEC node' % module) for parameter in self._secnode.modules[module]['parameters']: updatefunc = getattr(device, '_update_' + parameter, device._update) self._secnode.register_callback((module, parameter), updateEvent=updatefunc) try: data = self._secnode.cache[module, parameter] if data: updatefunc(module, parameter, *data) else: self.log.warning('No data for %s:%s' % (module, parameter)) except KeyError: self.log.warning('No cache for %s:%s' % (module, parameter))
def _read_controller(self, keys): line = '_read_controller %s' % keys self.log.debug(line) try: data = requests.get(self.url, timeout=self.timeout).json() self.log.debug(data) except requests.Timeout as e: self.log.info(line) self.log.info('url %s' % self.url) self.log.info('err %s' % e) raise CommunicationError(self, 'HTTP Timeout failed') except Exception as e: self.log.info(line) self.log.info('url %s' % self.url) self.log.info('err %s' % e) raise ConfigurationError(self, 'HTTP request failed') res = {} for key in keys: res[key] = data[key] return res
def _init(self, cid): try: if not self._is_corba_device(): raise ConfigurationError( self, 'Must be configured as "CORBA_device" (ID=500)') _config = ' '.join(self.config.split()[3:]) self.log.debug('reduced config: %s', _config) res = self._caressObject.init_module(INIT_NORMAL, cid, _config) self.log.debug('init module (Connect): %r', res) if res not in [(0, ON_LINE), (CARESS.OK, ON_LINE)]: res = self._caressObject.init_module(INIT_REINIT, cid, _config) self.log.debug('init module (Re-Init): %r', res) if res not in[(0, ON_LINE), (CARESS.OK, ON_LINE)]: self.log.error('Init module (Re-Init): %r (%d, %s)', res, cid, _config) raise NicosError(self, 'Could not initialize module!') self._initialized = True except CORBA.TRANSIENT as err: raise CommunicationError( self, 'could not init CARESS module %r (%d: %s)' % ( err, cid, self.config)) from err
def _generateSequence(self, target): seq = [] if not self.isAtTarget(self.doRead(0)): # The limited space at some positions requires a folding of the # instrument st_target = 60. if self.angle > -85. else 109. if st_target != self.stpos: raise ConfigurationError(self, 'st_target != stpos') # Only move if the setup (folding of 'st') is not correctly if abs(self._attached_st.read(0) - self.stpos) > \ self._attached_st.precision: seq.append(SeqDev(self._attached_tt, -60., stoppable=True)) seq.append( SeqDev(self._attached_st, self.stpos, stoppable=True)) # the configured positions are with offet = 0 ! # if the user changes the offset the change positions will not # change! tt_pos = self.angle - self._attached_tt.offset seq.append(SeqDev(self._attached_tt, tt_pos, stoppable=True)) seq.append(SeqDev(self._attached_block, target)) seq.append(SeqSleep(2)) return seq
def doInit(self, mode): KafkaCacheDatabase.doInit(self, mode) if self.historytopic not in self._consumer.topics(): raise ConfigurationError( 'Topic "%s" does not exit. Create this topic and restart.' % self.historytopic) # Create the history consumer self._history_consumer = KafkaConsumer(bootstrap_servers=self.brokers) if self._history_consumer is None: raise CommunicationError("Can't connect to %s" % self.brokers) self.log.warning('%r' % self._history_consumer.topics()) self.log.warning( '%r' % self._history_consumer.partitions_for_topic(self.historytopic)) partitions = self._history_consumer.partitions_for_topic( self.historytopic) self._history_consumer.assign( [TopicPartition(self.historytopic, p) for p in partitions])
def __init__(self, slit_number, defaultval): if 0 < slit_number < 5: self.slit = slit_number else: raise ConfigurationError('Slit %s is out of range.' % slit_number) self.defaultval = defaultval
def doInit(self, mode): if len(self._attached_moveables) != 3: raise ConfigurationError('I need exactly 3 attached moveables, %d ' 'given' % len(self._attached_moveables)) MultiSwitcher.doInit(self, mode)
def check(self, dev, aname, configargs): """Checks if the given arguments are valid for this entry. Also returns a list of all attached devices which should be created. May raise a configurationError, if something is wrongly configured. """ def check_count(multiple, optional, count): if (count == 0) and optional: return True # Don't change it to more pythonic style since we want to check for # the boolean 'True' value if self.multiple is True: return count > 0 return count in multiple if configargs: if isinstance(configargs, (tuple, list)): args = list(configargs) else: args = [configargs] else: args = [] if self.single: if check_count(self.multiple, self.optional, len(args)): return args or [None] raise ConfigurationError( dev, "device misses device %r in " "configuration" % aname) # Don't change it to more pythonic style since we want to check for # the boolean 'True' value if self.multiple is True: if check_count(self.multiple, self.optional, len(args)): return args raise ConfigurationError( dev, "wrong number of devices (%d) for %r" " in configuration (specified=%r)" % (len(args), aname, args)) # here we have: # - multiple is a list # - args has at least one real entry mindevs = min(self.multiple) maxdevs = max(self.multiple) # if optional, fill up to maxdevs with None if self.optional: args.extend([None] * (maxdevs - len(args))) # check number of devices if len(args) < mindevs: raise ConfigurationError( dev, "not enough devices (%d<%d) for %r" " in configuration (specified=%r)" % (len(args), mindevs, aname, args)) if len(args) > maxdevs: raise ConfigurationError( dev, "too many devices (%d>%d) for %r in " "configuration (specified=%r)" % (len(args), maxdevs, aname, args)) if check_count(self.multiple, self.optional, len(args)): return args raise ConfigurationError( dev, "wrong number of devices (%d) for %r in " "configuration (specified=%r)" % (len(args), aname, args))
def doUpdateCommentchar(self, value): if len(value) > 1: raise ConfigurationError('comment character should only be one ' 'character')
def doWritePos(self, target): if target == 0: raise ConfigurationError( self, "'%d' is an invalid value for " "parameter 'pos'" % target) self._attached_translation.move(target)
def makeDynamicDevices(self, setup_info): """create and destroy dynamic devices create devices from setup_info, and store the name of the setup creating the creator device in session.creator_devices for session.getSetupInfo() Based on the previous setup_info from self.setup_info, devices are created, recreated, destroyed or remain unchanged. If setup_info is empty, destroy all devices. """ prevdevices = set(self.setup_info.keys()) self._setROParam('setup_info', setup_info) # find setup of this secnode result = session.getSetupInfo() for setupname in session.loaded_setups: info = result.get(setupname, None) if info and self.name in info['devices']: break else: raise ConfigurationError('can not find setup') # add new or changed devices for devname, devcfg in setup_info.items(): prevdevices.discard(devname) dev = session.devices.get(devname, None) if dev: if not isinstance(dev, SecopDevice) or (dev._attached_secnode and dev._attached_secnode != self): self.log.error('device %s already exists' % devname) continue base = dev.__class__.__bases__[0] prevcfg = base.__module__ + '.' + base.__name__, dict(secnode=self.name, **dev._config) else: prevcfg = None if prevcfg != devcfg: session.configured_devices[devname] = devcfg session.dynamic_devices[devname] = setupname # pylint: disable=undefined-loop-variable if dev is None: # add new device session.createDevice(devname, recreate=True, explicit=True) dev = session.devices[devname] else: # modify existing device if dev._attached_secnode: dev._attached_secnode.unregisterDevice(dev) session.configured_devices[devname] = devcfg session.dynamic_devices[devname] = setupname # pylint: disable=undefined-loop-variable try: dev.replaceClass(devcfg[1]) dev.setAlive(self) except ConfigurationError: # above failed because an alias or attaching device requires a specific class # make old device defunct and replace by a new device session.destroyDevice(dev) session.dynamic_devices.pop(devname, None) session.createDevice(devname, recreate=True, explicit=True) prevdevices.discard(devname) dev = session.devices[devname] if not isinstance(dev, SecopReadable): # we will not get status updates for these dev.updateSecopStatus((SecopStatus.IDLE, '')) defunct = set() # defunct devices no longer available for devname in prevdevices: dev = session.devices.get(devname) if dev is None or dev._attached_secnode != self: continue if dev._sdevs: self.log.warning('defunct device is attached to %s' % ', '.join(dev._sdevs)) dev.setDefunct() defunct.add(devname) # inform client that setups have changed session.setupCallback(list(session.loaded_setups), list(session.explicit_setups))
def doUpdateUnit(self, unit): factor = units.get(unit, None) if factor is None: raise ConfigurationError('Unsupported unit, allowed: %s' % ','.join(units)) self._factor = factor
def doInit(self, mode): if self._attached_l.unit != self._attached_d.unit: raise ConfigurationError( self, 'different units for L and d ' '(%s vs %s)' % (self._attached_l.unit, self._attached_d.unit))