def doInit(self, mode): if self.fallback in self.mapping: raise ConfigurationError( self, 'Value of fallback parameter is ' 'not allowed to be in the mapping!') self._devices = { dev.name: dev for dev in (self._attached_anodes + self._attached_banodes + self._attached_cathodes + self._attached_window) } if len(self._attached_anodes) != len(self._attached_banodes) + 1: raise ConfigurationError( self, 'Number of anode devices must be ' 'the number of boundary anodes + 1: %d, ' '%d' % (len(self.anodes), len(self.banodes))) # if not self.relax_mapping: # self.valuetype = oneof(*sorted(self.mapping, key=num_sort)) for value in sorted(self.mapping, key=num_sort): try: self.valuetype(value) except ValueError as err: raise ConfigurationError( self, '%r not allowed as key in mapping. %s' % (value, err)) from err
def doInit(self, _mode): self._masters = [] self._slaves = [] self._channel_presets = {} self._postprocess = [] self._postpassives = [] for tup in self.postprocess: if tup[0] not in session.configured_devices: self.log.warning( "device %r not found but configured in " "'postprocess' parameter. No " "post processing for this device. Please " "check the detector setup.", tup[0]) continue postdev = session.getDevice(tup[0]) img_or_passive_devs = [session.getDevice(name) for name in tup[1:]] if not isinstance(postdev, PostprocessPassiveChannel): raise ConfigurationError("Device '%s' is not a " "PostprocessPassiveChannel" % postdev.name) if postdev not in self._channels: raise ConfigurationError("Device '%s' has not been configured " "for this detector" % postdev.name) for dev in img_or_passive_devs: if dev not in self._channels: raise ConfigurationError("Device '%s' has not been " "configured for this detector" % dev.name) elif isinstance(dev, PassiveChannel): self._postpassives.append(dev) self._postprocess.append((postdev, img_or_passive_devs))
def _d(self, maxage=0): crystal = self._crystal() if crystal: p = crystal.get(self.plane, None) if p: return p[0] raise ConfigurationError('No plane of the crystal set.') raise ConfigurationError('No crystal set.')
def doInit(self, mode): if not self._attached_moveable.isAllowed(self.onvalue)[0]: raise ConfigurationError( self, "'onvalue' is not allowed for the " "'%s' device" % self._attached_moveable) if not self._attached_moveable.isAllowed(self.offvalue)[0]: raise ConfigurationError( self, "'offvalue' is not allowed for the " "'%s' device" % self._attached_moveable) self.valuetype = oneof(self.offvalue, self.onvalue)
def doInit(self, mode): units = set(d.unit for d in self._adevs.values()) if len(units) != 1: raise ConfigurationError( self, 'different units for L, d and sdd ' '(%s vs %s vs %s)' % (self._attached_l.unit, self._attached_d.unit, self._attached_sdd.unit)) if 'mm' not in units: raise ConfigurationError( self, "attached devices units have to be " "'mm'")
def doStart(self, target): crystal = self._crystal() if not crystal: raise ConfigurationError(self, 'Not valid setup') plane = crystal.get(self.plane, None) if not plane: raise ConfigurationError(self, 'No valid mono configuration') tthm = asin(target / (2 * self._d())) / pi * 360. omgm = tthm / 2.0 + plane[1] + plane[2] self.log.debug(self._attached_base, 'will be moved to %.3f' % tthm) self.log.debug(self._attached_omgm, 'will be moved to %.3f' % omgm) if self._attached_base.isAllowed(tthm) and \ self._attached_omgm.isAllowed(omgm): self._attached_base.start(tthm) self._attached_omgm.start(omgm)
def doInit(self, mode): MemoryCacheDatabase.doInit(self, mode) # Create the producer self._producer = KafkaProducer(bootstrap_servers=self.brokers) # Create the consumer self._consumer = KafkaConsumer( bootstrap_servers=self.brokers, auto_offset_reset='earliest' # start at earliest topic ) # Give up if the topic does not exist if self.currenttopic not in self._consumer.topics(): raise ConfigurationError( 'Topic "%s" does not exit. Create this topic and restart.' % self.currenttopic) # Assign the partitions partitions = self._consumer.partitions_for_topic(self.currenttopic) self._consumer.assign( [TopicPartition(self.currenttopic, p) for p in partitions]) # Cleanup thread configuration self._stoprequest = False self._cleaner = createThread('cleaner', self._clean, start=False)
def replaceClass(self, config): """replace the class on the fly happens when the structure fo the device has changed """ cls = self.__class__.__bases__[0] newclass = cls.makeDevClass(self.name, **config) bad_attached = False for dev, cls in get_attaching_devices(self): if issubclass(newclass, cls): self.log.warning('reattach %s to %s' % (dev.name, self.name)) else: self.log.error('can not attach %s to %s' % (dev.name, self.name)) bad_attached = True if bad_attached: raise ConfigurationError('device class mismatch') for dev, cls in get_aliases(self): if issubclass(newclass, cls): self.log.warning('redirect alias %s to %s' % (dev.name, self.name)) else: self.log.error('release alias %s from %s' % (dev.name, self.name)) dev.alias = '' self.__class__ = newclass # as we do not go through self.__init__ again, we have to update self._config self._config = dict((name.lower(), value) for (name, value) in config.items()) for aname in self.attached_devices: self._config.pop(aname, None)
def doPreinit(self, mode): if len(self._attached_others) != 1 or not isinstance( self._attached_others[0], Configuration): raise ConfigurationError( 'pilatus detectors require exactly one "other" channel that ' 'is an instance of {}'.format(Configuration)) self._cfg_channel = self._attached_others[0]._dev GenericDetector.doPreinit(self, mode)
def _get_pv_name(self, pvparam): prefix = getattr(self, 'basepv') if pvparam == 'alarm': return prefix + 'ALARM' elif pvparam == 'values': return prefix + 'VALUES' else: raise ConfigurationError( 'requested invalid pv %s for LMD400' % (pvparam))
def doInit(self, mode): if any(idx < 10 or idx > 19 for idx, _ in self.workspaces): raise ConfigurationError("Workspace ids muste be in 10..19 " "(Jülich workspace range)") if mode != SIMULATION: workspaces = self._dev.workspaces # Tango get workspaces for wsid, ws in self.workspaces: workspaces[wsid] = ws self._dev.workspaces = workspaces # Tango set workspaces
def doWritePlane(self, target): crystal = self._crystal() if crystal: if not crystal.get(target, None): raise ValueError('The "%s" plane is not allowed for "%s" ' 'crystal' % (target, crystal)) else: raise ConfigurationError('No valid setup of the monochromator') return target
def doInit(self, _mode): for dev_name in self.detectors: detector = session.getDevice(dev_name) for img in detector._attached_images: if not isinstance(session.getDevice(img), ImageChannel): raise ConfigurationError( 'mythen image sink can only be used by detector ' 'devices that come up with image channels that are ' 'instances of {}'.format(ImageChannel))
def _get_pv_name(self, pvparam): prefix = getattr(self, 'basepv') if pvparam == 'target': return prefix + 'RUN' elif pvparam == 'readback': return prefix + 'RUNRBV' else: raise ConfigurationError( 'requested invalid pv %s for radial collimator' % (pvparam))
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 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 _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 _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 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 __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 _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 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 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