class ProxiesDict(CaselessDefaultDict,Object): ''' Dictionary that stores PyTango.DeviceProxies/AttributeProxies It is like a normal dictionary but creates a new proxy each time that the "get" method is called All keys translated to full tango URIs (fqdn=True by default) An earlier version is used in PyTangoArchiving.utils module Taurus3+ support is not tested ''' def __init__(self,use_tau = False, tango_host = ''): self.log = Logger('ProxiesDict') self.log.setLogLevel('INFO') self.use_tau = TAU and use_tau self.tango_host = tango_host self.call__init__(CaselessDefaultDict,self.__default_factory__) def translate(self, dev): try: attr = get_attr_name(dev,False) if self.tango_host and ':' not in dev: dev = self.tango_host + '/' + dev dev = get_dev_name(dev,full=True,fqdn=True).lower() except: dev = get_dev_name(dev,full=True,fqdn=False).lower() if attr: dev += '/'+attr return dev def __default_factory__(self,dev_name): ''' Called by defaultdict_fromkey.__missing__ method If a key doesn't exists this method is called and returns a proxy for a given device. If the proxy caused an exception (usually because device doesn't exists) a None value is returned ''' dev_name = self.translate(dev_name) if dev_name not in self.keys(): self.log.debug( 'Getting a Proxy for %s'%dev_name) try: devklass,attrklass = (TAU.Device,TAU.Attribute) \ if self.use_tau else \ (PyTango.DeviceProxy,PyTango.AttributeProxy) klass = (devklass,attrklass)[get_attr_name(dev_name,False)] dev = klass(dev_name) except Exception,e: print('ProxiesDict: %s doesnt exist!'%dev_name) dev = None return dev
def __init__(self, pattern='', klass='', devs_list='', servers_list='', hosts='', loadAll=False, log='WARNING', logger=None, tango_host='', host='', devices=''): ''' def __init__(self,pattern='', klass='',devs_list='',servers_list=''): The ServersDict can be initialized using any of the three argument lists or a wildcard for Database.get_server_list(pattern) ServersDict('*') can be used to load all servers in database ''' self.call__init__(CaselessDict, self) if logger is None: self.log = Logger('ServersDict') self.log.setLogLevel(log) else: self.log = logger self.log.debug('ServersDict(%s)' % ','.join( map(str, (pattern, klass, devs_list, servers_list, hosts, loadAll, log, logger, tango_host)))) ## proxies will keep a list of persistent device proxies self.proxies = ProxiesDict(tango_host=tango_host) ## db will keep a persistent link to PyTango database self.db = get_database() if not tango_host else get_database( *(tango_host.split(':'))) self.server_names = self.keys self.servers = self.values if loadAll: self.load_all_servers() elif klass: self.load_by_class(klass) elif devs_list: self.load_from_devs_list(devs_list) elif devices: self.load_from_devs_list(devices) elif servers_list: self.load_from_servers_list(servers_list) #elif pattern: self.load_from_servers_list(self.db.get_server_list(pattern)) elif hosts: hosts = type(hosts) is str and (',' in hosts and hosts.split(',') or [hosts]) or hosts for h in hosts: self.load_by_host(h) elif host: self.load_by_host(host) elif pattern: self.load_by_name(pattern)
def __init__(self,pattern='',klass='',devs_list='',servers_list='',hosts='',loadAll=False,log='WARNING',logger=None,tango_host=''): ''' def __init__(self,pattern='', klass='',devs_list='',servers_list=''): The ServersDict can be initialized using any of the three argument lists or a wildcard for Database.get_server_list(pattern) ServersDict('*') can be used to load all servers in database ''' self.call__init__(CaselessDict,self) if logger is None: self.log = Logger('ServersDict') self.log.setLogLevel(log) else: self.log=logger self.log.debug('ServersDict(%s)'%','.join(map(str,(pattern,klass,devs_list,servers_list,hosts,loadAll,log,logger,tango_host)))) ## proxies will keep a list of persistent device proxies self.proxies = ProxiesDict() ## db will keep a persistent link to PyTango database self.db = get_database() if not tango_host else get_database(*(tango_host.split(':'))) self.server_names = self.keys self.servers = self.values if loadAll: self.load_all_servers() elif klass: self.load_by_class(klass) elif devs_list: self.load_from_devs_list(devs_list) elif servers_list: self.load_from_servers_list(servers_list) #elif pattern: self.load_from_servers_list(self.db.get_server_list(pattern)) elif hosts: hosts = type(hosts) is str and (',' in hosts and hosts.split(',') or [hosts]) or hosts for h in hosts: self.load_by_host(h) elif pattern: self.load_by_name(pattern)
def __init__(self, schema, host=None, user='******', passwd='browser', classes=[], LogLevel='info', load=True, logger=None): """ """ self.log = logger or Logger( 'ArchivingAPI(%s)' % schema, format='%(levelname)-8s %(asctime)s %(name)s: %(message)s') self.log.setLogLevel(LogLevel) self.log.debug('Logger streams initialized (error,warning,info,debug)') self.tango = PyTango.Database() #access to Tango database self.api = self #hook used by legacy packages self.servers = None self.schema = str(schema).lower() self.user, self.passwd = user, passwd if host is None: prop = self.tango.get_class_property('%sArchiver' % schema, ['DbHost'])['DbHost'] if not prop: print('ERROR: %sArchiver.DbHost property not defined!' % schema) self.host = None else: self.host = prop[0] #if 'TANGO_HOST' in os.environ: # self.host=os.environ['TANGO_HOST'].split(':')[0] else: self.host = host self.dbs = {} #pointers to Archiving databases self.ArchivingClasses = classes or self.get_archiving_classes() self.ArchiverClass = (k for k in self.ArchivingClasses if 'Archiver' in k).next() self.ManagerClass = (k for k in self.ArchivingClasses if 'Manager' in k).next() self.ExtractorClass = (k for k in self.ArchivingClasses if 'Extractor' in k).next() try: self.WatcherClass = (k for k in self.ArchivingClasses if 'Watcher' in k).next() except: self.WatcherClass = None self.loads = CaselessDefaultDict( lambda k: 0) #a dict with the archiving load for each device self.attributes = CaselessDict() #a dict of ArchivedAttribute objects self.dedicated = CaselessDefaultDict(lambda k: set( )) #Dictionary for keeping the attributes reserved for each archiver if load and self.host and self.ArchivingClasses: self.load_servers()
def __init__(self, name='', host='', parent=None): if not name or '/' not in name: raise Exception, 'TServer_WrongServerName_%s' % name self.info = None self.name = self.get_simple_name(name) self.update_level(host, 0) self.controlled = False self.level = 0 self._classes = None self.state = None #PyTango.DevState.UNKNOWN self.log = Logger('TServer-%s' % name) if parent and parent.log.getLogLevel(): self.log.setLogLevel(parent.log.getLogLevel()) else: self.log.setLogLevel('ERROR') self.state_lock = threading.Lock() if parent: self.proxies = parent.proxies else: self.proxies = ProxiesDict() pass
class ProxiesDict(CaselessDefaultDict,Object): ''' Dictionary that stores PyTango.DeviceProxies It is like a normal dictionary but creates a new proxy each time that the "get" method is called An earlier version is used in PyTangoArchiving.utils module This class must be substituted by Tau.Core.TauManager().getFactory()() ''' def __init__(self,use_tau = False, tango_host = ''): self.log = Logger('ProxiesDict') self.log.setLogLevel('INFO') self.use_tau = TAU and use_tau self.tango_host = tango_host self.call__init__(CaselessDefaultDict,self.__default_factory__) def __default_factory__(self,dev_name): ''' Called by defaultdict_fromkey.__missing__ method If a key doesn't exists this method is called and returns a proxy for a given device. If the proxy caused an exception (usually because device doesn't exists) a None value is returned ''' if self.tango_host and ':' not in dev_name: dev_name = self.tango_host + '/' + dev_name if dev_name not in self.keys(): self.log.debug( 'Getting a Proxy for %s'%dev_name) try: devklass,attrklass = (TAU.Device,TAU.Attribute) \ if self.use_tau else \ (PyTango.DeviceProxy,PyTango.AttributeProxy) dev = (attrklass if str(dev_name).count('/')==(4 if ':' in dev_name else 3) else devklass)(dev_name) except Exception,e: print('ProxiesDict: %s doesnt exist!'%dev_name) dev = None return dev
def __init__(self,name='', host='', parent=None): if not name or '/' not in name: raise Exception,'TServer_WrongServerName_%s' % name self.info = None self.name=self.get_simple_name(name) self.update_level(host,0) self.controlled = False self.level = 0 self._classes = None self.state=None #PyTango.DevState.UNKNOWN self.log = Logger('TServer-%s'%name) if parent and parent.log.getLogLevel(): self.log.setLogLevel(parent.log.getLogLevel()) else: self.log.setLogLevel('ERROR') self.state_lock = threading.Lock() if parent: self.proxies=parent.proxies else: self.proxies=ProxiesDict() pass
class TServer(Object): '''Class used by ServerDict to manage TangoDeviceServer admin devices.''' def __init__(self, name='', host='', parent=None): if not name or '/' not in name: raise Exception, 'TServer_WrongServerName_%s' % name self.info = None self.name = self.get_simple_name(name) self.update_level(host, 0) self.controlled = False self.level = 0 self._classes = None self.state = None #PyTango.DevState.UNKNOWN self.log = Logger('TServer-%s' % name) if parent and parent.log.getLogLevel(): self.log.setLogLevel(parent.log.getLogLevel()) else: self.log.setLogLevel('ERROR') self.state_lock = threading.Lock() if parent: self.proxies = parent.proxies else: self.proxies = ProxiesDict() pass def set_state(self, state): self.state_lock.acquire() self.state = state self.state_lock.release() def ping(self, dname=None): '''Executes .ping() and .state() methods of the admin device.''' name = dname or self.get_admin_name() wait = threading.Event().wait if not dname: self.set_state(None) try: proxy = self.get_proxy(name) except: self.log.error('%s.ping() ... %s not in database!!!' % (self.name, name)) return None wait(.01) #this wait allows parallel threads try: proxy.ping() except: #self.log.debug( '%s.ping() ... Alive'%s_name) return None if not dname: self.set_state( PyTango.DevState.FAULT ) #Device pings but its state is not readable (ZOMBIE) wait(.01) #this wait allows parallel threads try: result = proxy.state() if not dname: self.set_state(result) return result except: if not dname: return self.state else: return None def init_from_db(self, db=None, load_devices=False): """ Gets name, classes, devices, host, level information from Tango Database. """ self._db = db or (self._db if hasattr(self, '_db') else PyTango.Database()) #print ('init_from_db(%s,%s,%s)'%(self.name,get_tango_host(self._db),load_devices)) self.info = self._db.get_server_info(self.name) di = get_device_info( 'dserver/' + self.name, db=self._db ) #get_server_info() must be combined with get_device_info to obtain the real name of the launcher self.name = di.server self.update_level(self.info.host, self.info.level) if load_devices: self.get_classes() def update_level(self, host, level=0): """ It only initializes the values, does not get values from database. """ self.controlled = True if host or level else False if type(level) is str: level = level.strip() if self.controlled: self.host, self.level = host.split('.')[0].strip(), trial( int, args=level, excepts=0) else: self.host, self.level = '', 0 def get_classes(self, load=False): if not load and self._classes is not None: return self._classes devs = self._db.get_device_class_list(self.name) self._classes = collections.defaultdict(list) #print 'loading from %s server:%s'%(s,str(devs)) for i in range(0, len(devs), 2): klass = devs[i + 1] self._classes[klass].append(devs[i].lower()) return self._classes classes = property(fget=get_classes) def get_server_level(self): """ It returns initialized values, does not get values from database. """ if self.controlled and self.host: return self.host, self.level else: return '', 0 def get_simple_name(self, name=''): '''Returns the name of the server in the Server/Instance format.''' name = name or self.name return name if name.count('/') == 1 else name.split('/', 1)[1] def get_tango_host(self): return get_tango_host(self._db) def get_admin_name(self): '''Returns the name of the server in the dserver/Server/Instance format.''' n = 'dserver/' + self.name if self.name.count('/') == 1 else self.name return self.get_tango_host() + '/' + n def get_starter_name(self): """Returns the starter on charge of controlling this server.""" n = 'tango/admin/%s' % self.host if self.host else None return self.get_tango_host() + '/' + n def get_device_list(self): '''Returns a list of devices declared for this server.''' result = [] [ result.extend(v) for c, v in self.classes.items() if c.lower() != 'dserver' ] return result def get_proxy(self, device=''): '''Returns a proxy to the given device; or the admin device if no device name is provided.''' if device and ':' not in device: device = self.get_tango_host() + '/' + device device = device or self.get_admin_name() return self.proxies.get(device) def get_admin(self): return self.get_proxy() def get_device(self, device): return self.get_proxy(device) def get_all_states(self): """Returns a dictionary with the individual states of the inner devices.""" result = {} for klass in self.classes: for device in self.classes[klass]: try: result[device] = self.proxies[device].State() except Exception, e: self.log.warning('Unable to read %s state: %s' % (device, str(e)[:100] + '...')) result[device] = None #PyTango.DevState.UNKNOWN return result
class ServersDict(CaselessDict, Object): ''' Dictionary of TServer classes indexed by server/instance names and loaded using wildcard expressions. Provides Jive/Astor functionality to a list of servers and allows to select/start/stop them by host, class or devices Its purpose is to allow generic start/stop of lists of Tango DeviceServers. This methods of selection provide new ways of search apart of Jive-like selection. @attention Dict keys are lower case, to get the real server name each key returns a TServer object with a .name attribute @par Usage: <pre> from fandango import Astor astor = Astor() astor.load_by_name('snap*') astor.keys() ['snapmanager/1', 'snaparchiver/1', 'snapextractor/1'] server = astor['snaparchiver/1'] server.get_device_list() ['dserver/snaparchiver/1', 'archiving/snaparchiver/1'] astor.states() server.get_all_states() dserver/snaparchiver/1: ON archiving/snaparchiver/1: ON astor.get_device_host('archiving/snaparchiver/1') palantir01 astor.stop_servers('snaparchiver/1') astor.stop_all_servers() astor.start_servers('snaparchiver/1','palantir01',wait=1000) astor.set_server_level('snaparchiver/1','palantir01',4) #Setting the polling of a device: server = astor['PySignalSimulator/bl11'] for dev_name in server.get_device_list(): dev = server.get_device(dev_name) attrs = dev.get_attribute_list() [dev.poll_attribute(attr,3000) for attr in attrs] </pre> ''' def __init__(self, pattern='', klass='', devs_list='', servers_list='', hosts='', loadAll=False, log='WARNING', logger=None, tango_host=''): ''' def __init__(self,pattern='', klass='',devs_list='',servers_list=''): The ServersDict can be initialized using any of the three argument lists or a wildcard for Database.get_server_list(pattern) ServersDict('*') can be used to load all servers in database ''' self.call__init__(CaselessDict, self) if logger is None: self.log = Logger('ServersDict') self.log.setLogLevel(log) else: self.log = logger self.log.debug('ServersDict(%s)' % ','.join( map(str, (pattern, klass, devs_list, servers_list, hosts, loadAll, log, logger, tango_host)))) ## proxies will keep a list of persistent device proxies self.proxies = ProxiesDict(tango_host=tango_host) ## db will keep a persistent link to PyTango database self.db = get_database() if not tango_host else get_database( *(tango_host.split(':'))) self.server_names = self.keys self.servers = self.values if loadAll: self.load_all_servers() elif klass: self.load_by_class(klass) elif devs_list: self.load_from_devs_list(devs_list) elif servers_list: self.load_from_servers_list(servers_list) #elif pattern: self.load_from_servers_list(self.db.get_server_list(pattern)) elif hosts: hosts = type(hosts) is str and (',' in hosts and hosts.split(',') or [hosts]) or hosts for h in hosts: self.load_by_host(h) elif pattern: self.load_by_name(pattern) #dict.__init__(self) ## @name Dict methods # @{ def __arranged_key(self, key): return key if key.count('/') <= 1 else key.split('/', 1)[1] #def __getitem__(self,key): dicts.CaselessDict.__getitem__(self,self.__arranged_key(key)) #def __setitem__(self,key,value): dicts.CaselessDict.__setitem__(self,self.__arranged_key(key),value) #def __delitem__(self,key): dicts.CaselessDict.__delitem__(self,self.__arranged_key(key)) #def __contains__(self,key): dicts.CaselessDict.__contains__(self,self.__arranged_key(key)) #def has_key(self,key): dicts.CaselessDict.has_key(self,self.__arranged_key(key)) #def get(self,key,def_val=None): dicts.CaselessDict.get(self,self.__arranged_key(key),def_val) #def pop(self,key,def_val=None): dicts.CaselessDict.pop(self,self.__arranged_key(key),def_val) #def setdefault(self,key,def_val=None): dicts.CaselessDict.pop(self,self.__arranged_key(key),def_val) def __repr__(self): return self.get_report() def __str__(self): return self.get_report() ## @} ## @name Database access # @{ def load_all_servers(self): """ It loads all device servers declared in Tango database """ #classes = self.db.get_device_family('dserver/*') #for c in classes: # self.load_by_exec(c) print self.db self.load_from_servers_list(self.db.get_server_list()) def load_by_name(self, name): ''' Initializes the dict with all the servers matching a given name (usually the executable name or class). A list of names is also possible.''' if type(name) in (list, set): for pattern in name: self.load_by_name(pattern) else: if name.count('/') >= 2 and not name.startswith('dserver/'): return self.load_from_devs_list([name]) else: server_name = name.replace('dserver/', '') self.log.info('loading by %s server_name' % server_name) family = server_name.split( '/')[0] if '/' in server_name else server_name member = server_name.split( '/')[1] if '/' in server_name else '*' servers_list = self.get_devs_from_db('dserver/%s/%s' % (family, member)) #servers_list = [s for s in self.db.get_server_list() if fun.matchCl('%s/%s'%(family,member),s)] if servers_list: self.load_from_servers_list( [d.replace('dserver/', '') for d in servers_list], check=False) self.log.info('%d servers loaded' % len(servers_list)) return len(servers_list) else: self.log.warning('No server matches with %s (family=%s).' % (server_name, family)) return 0 return self def load_by_class(self, klass): """ Initializes the ServersDict using all the devices from a given class """ self.load_from_devs_list(get_class_devices(klass)) def load_by_host(self, host): """ Initializes the dict with all the servers assigned to a given host. """ servers = self.get_db_device().DbGetHostServerList(host) self.log.warning("%d servers assigned in DB to host %s: %s" % (len(servers), host, servers)) if servers: self.load_from_servers_list(servers) return self def load_from_devs_list(self, devs_list): ''' Initializes the dict using a list of devices; a query to the database is used to identify the server for each device. ''' if type(devs_list) is str: devs_list = devs_list.split(',') if type(devs_list) not in [list, set, tuple]: devs_list = [devs_list] servers_list = set() for d in devs_list: devs = self.get_devs_from_db(d) if '*' in d else [d] devs = [get_normal_name(d) for d in devs] [ servers_list.add(self.get_device_server(dev)) for dev in devs if dev ] self.log.info('Loading %d servers matching %s devices' % (len(servers_list), len(devs_list))) self.load_from_servers_list([s for s in servers_list if s]) return self def load_from_servers_list(self, servers_list, check=True): """ Initializes the dictionary using a list of server_names like ['Exec/Instance'] """ t0 = time.time() if type(servers_list) is str: servers_list = servers_list.split(',') if check: self.check_servers_names(servers_list) for s in servers_list: try: self.log.debug('loading from %s/%s server' % (get_tango_host(self.db), s)) ss = TServer(name=s, parent=self) ss.init_from_db(self.db) self[s] = ss except Exception, e: self.log.warning('exception loading %s server: %s' % (s, str(e)[:100] + '...')) print traceback.format_exc() self.log.debug('load_from_servers_list(%d) took %f seconds' % (len(servers_list), time.time() - t0)) return self
class TServer(Object): '''Class used by ServerDict to manage TangoDeviceServer admin devices.''' def __init__(self,name='', host='', parent=None): if not name or '/' not in name: raise Exception,'TServer_WrongServerName_%s' % name self.info = None self.name=self.get_simple_name(name) self.update_level(host,0) self.controlled = False self.level = 0 self._classes = None self.state=None #PyTango.DevState.UNKNOWN self.log = Logger('TServer-%s'%name) if parent and parent.log.getLogLevel(): self.log.setLogLevel(parent.log.getLogLevel()) else: self.log.setLogLevel('ERROR') self.state_lock = threading.Lock() if parent: self.proxies=parent.proxies else: self.proxies=ProxiesDict() pass def set_state(self,state): self.state_lock.acquire() self.state=state self.state_lock.release() def ping(self,dname=None): '''Executes .ping() and .state() methods of the admin device.''' name = dname or self.get_admin_name() wait = threading.Event().wait if not dname: self.set_state(None) try: proxy = self.get_proxy(name) except: self.log.error('%s.ping() ... %s not in database!!!' % (self.name,name)) return None wait(.01) #this wait allows parallel threads try: proxy.ping() except: #self.log.debug( '%s.ping() ... Alive'%s_name) return None if not dname: self.set_state(PyTango.DevState.FAULT) #Device pings but its state is not readable (ZOMBIE) wait(.01) #this wait allows parallel threads try: result = proxy.state() if not dname: self.set_state(result) return result except: if not dname: return self.state else: return None def init_from_db(self,db=None,load_devices=False): """ Gets name, classes, devices, host, level information from Tango Database. """ self._db = db or (self._db if hasattr(self,'_db') else PyTango.Database()) #print ('init_from_db(%s,%s,%s)'%(self.name,get_tango_host(self._db),load_devices)) self.info = self._db.get_server_info(self.name) di = get_device_info('dserver/'+self.name,db=self._db) #get_server_info() must be combined with get_device_info to obtain the real name of the launcher self.name = di.server self.update_level(self.info.host,self.info.level) if load_devices: self.get_classes() def update_level(self,host,level=0): """ It only initializes the values, does not get values from database. """ self.controlled = True if host or level else False if type(level) is str: level=level.strip() if self.controlled: self.host,self.level = host.split('.')[0].strip(),trial(int,args=level,excepts=0) else: self.host,self.level = '',0 def get_classes(self,load=False): if not load and self._classes is not None: return self._classes devs = self._db.get_device_class_list(self.name) self._classes = collections.defaultdict(list) #print 'loading from %s server:%s'%(s,str(devs)) for i in range(0,len(devs),2): klass = devs[i+1] self._classes[klass].append(devs[i].lower()) return self._classes classes = property(fget=get_classes) def get_server_level(self): """ It returns initialized values, does not get values from database. """ if self.controlled and self.host: return self.host,self.level else: return '',0 def get_simple_name(self,name=''): '''Returns the name of the server in the Server/Instance format.''' name = name or self.name return name if name.count('/')==1 else name.split('/',1)[1] def get_tango_host(self): return get_tango_host(self._db) def get_admin_name(self): '''Returns the name of the server in the dserver/Server/Instance format.''' n = 'dserver/'+self.name if self.name.count('/')==1 else self.name return self.get_tango_host()+'/'+n def get_starter_name(self): """Returns the starter on charge of controlling this server.""" n = 'tango/admin/%s' % self.host if self.host else None return self.get_tango_host()+'/'+n def get_device_list(self): '''Returns a list of devices declared for this server.''' result=[] [result.extend(v) for c,v in self.classes.items() if c.lower()!='dserver'] return result def get_proxy(self,device=''): '''Returns a proxy to the given device; or the admin device if no device name is provided.''' if device and ':' not in device: device = self.get_tango_host()+'/'+device device = device or self.get_admin_name() return self.proxies.get(device) def get_admin(self): return self.get_proxy() def get_device(self,device): return self.get_proxy(device) def get_all_states(self): """Returns a dictionary with the individual states of the inner devices.""" result = {} for klass in self.classes: for device in self.classes[klass]: try: result[device] = self.proxies[device].State() except Exception,e: self.log.warning('Unable to read %s state: %s' % (device,str(e)[:100]+'...')) result[device] = None #PyTango.DevState.UNKNOWN return result
class ServersDict(CaselessDict,Object): ''' Dictionary of TServer classes indexed by server/instance names and loaded using wildcard expressions. Provides Jive/Astor functionality to a list of servers and allows to select/start/stop them by host, class or devices Its purpose is to allow generic start/stop of lists of Tango DeviceServers. This methods of selection provide new ways of search apart of Jive-like selection. @attention Dict keys are lower case, to get the real server name each key returns a TServer object with a .name attribute @par Usage: <pre> from fandango import Astor astor = Astor() astor.load_by_name('snap*') astor.keys() ['snapmanager/1', 'snaparchiver/1', 'snapextractor/1'] server = astor['snaparchiver/1'] server.get_device_list() ['dserver/snaparchiver/1', 'archiving/snaparchiver/1'] astor.states() server.get_all_states() dserver/snaparchiver/1: ON archiving/snaparchiver/1: ON astor.get_device_host('archiving/snaparchiver/1') palantir01 astor.stop_servers('snaparchiver/1') astor.stop_all_servers() astor.start_servers('snaparchiver/1','palantir01',wait=1000) astor.set_server_level('snaparchiver/1','palantir01',4) #Setting the polling of a device: server = astor['PySignalSimulator/bl11'] for dev_name in server.get_device_list(): dev = server.get_device(dev_name) attrs = dev.get_attribute_list() [dev.poll_attribute(attr,3000) for attr in attrs] </pre> ''' def __init__(self,pattern='',klass='',devs_list='',servers_list='',hosts='',loadAll=False,log='WARNING',logger=None,tango_host=''): ''' def __init__(self,pattern='', klass='',devs_list='',servers_list=''): The ServersDict can be initialized using any of the three argument lists or a wildcard for Database.get_server_list(pattern) ServersDict('*') can be used to load all servers in database ''' self.call__init__(CaselessDict,self) if logger is None: self.log = Logger('ServersDict') self.log.setLogLevel(log) else: self.log=logger self.log.debug('ServersDict(%s)'%','.join(map(str,(pattern,klass,devs_list,servers_list,hosts,loadAll,log,logger,tango_host)))) ## proxies will keep a list of persistent device proxies self.proxies = ProxiesDict() ## db will keep a persistent link to PyTango database self.db = get_database() if not tango_host else get_database(*(tango_host.split(':'))) self.server_names = self.keys self.servers = self.values if loadAll: self.load_all_servers() elif klass: self.load_by_class(klass) elif devs_list: self.load_from_devs_list(devs_list) elif servers_list: self.load_from_servers_list(servers_list) #elif pattern: self.load_from_servers_list(self.db.get_server_list(pattern)) elif hosts: hosts = type(hosts) is str and (',' in hosts and hosts.split(',') or [hosts]) or hosts for h in hosts: self.load_by_host(h) elif pattern: self.load_by_name(pattern) #dict.__init__(self) ## @name Dict methods # @{ def __arranged_key(self,key): return key if key.count('/')<=1 else key.split('/',1)[1] #def __getitem__(self,key): dicts.CaselessDict.__getitem__(self,self.__arranged_key(key)) #def __setitem__(self,key,value): dicts.CaselessDict.__setitem__(self,self.__arranged_key(key),value) #def __delitem__(self,key): dicts.CaselessDict.__delitem__(self,self.__arranged_key(key)) #def __contains__(self,key): dicts.CaselessDict.__contains__(self,self.__arranged_key(key)) #def has_key(self,key): dicts.CaselessDict.has_key(self,self.__arranged_key(key)) #def get(self,key,def_val=None): dicts.CaselessDict.get(self,self.__arranged_key(key),def_val) #def pop(self,key,def_val=None): dicts.CaselessDict.pop(self,self.__arranged_key(key),def_val) #def setdefault(self,key,def_val=None): dicts.CaselessDict.pop(self,self.__arranged_key(key),def_val) def __repr__(self): return self.get_report() def __str__(self): return self.get_report() ## @} ## @name Database access # @{ def load_all_servers(self): """ It loads all device servers declared in Tango database """ #classes = self.db.get_device_family('dserver/*') #for c in classes: # self.load_by_exec(c) print self.db self.load_from_servers_list(self.db.get_server_list()) def load_by_name(self,name): ''' Initializes the dict with all the servers matching a given name (usually the executable name or class). A list of names is also possible.''' if type(name) in (list,set): for pattern in name: self.load_by_name(pattern) else: if name.count('/')>=2 and not name.startswith('dserver/'): return self.load_from_devs_list([name]) else: server_name = name.replace('dserver/','') self.log.info('loading by %s server_name'%server_name) family = server_name.split('/')[0] if '/' in server_name else server_name member = server_name.split('/')[1] if '/' in server_name else '*' servers_list = self.get_devs_from_db('dserver/%s/%s' % (family,member)) #servers_list = [s for s in self.db.get_server_list() if fun.matchCl('%s/%s'%(family,member),s)] if servers_list: self.load_from_servers_list([d.replace('dserver/','') for d in servers_list],check=False) self.log.info('%d servers loaded'%len(servers_list)) return len(servers_list) else: self.log.warning('No server matches with %s (family=%s).'%(server_name,family)) return 0 return self def load_by_class(self,klass): """ Initializes the ServersDict using all the devices from a given class """ self.load_from_devs_list(get_class_devices(klass)) def load_by_host(self,host): """ Initializes the dict with all the servers assigned to a given host. """ servers = self.get_db_device().DbGetHostServerList(host) self.log.warning("%d servers assigned in DB to host %s: %s" % (len(servers),host,servers)) if servers: self.load_from_servers_list(servers) return self def load_from_devs_list(self,devs_list): ''' Initializes the dict using a list of devices; a query to the database is used to identify the server for each device. ''' if type(devs_list) is str: devs_list = devs_list.split(',') if type(devs_list) not in [list,set,tuple]: devs_list = [devs_list] servers_list=set() for d in devs_list: devs = self.get_devs_from_db(d) if '*' in d else [d] [servers_list.add(self.get_device_server(dev)) for dev in devs if dev] self.log.info('Loading %d servers matching %s devices'%(len(servers_list),len(devs_list))) self.load_from_servers_list([s for s in servers_list if s]) return self def load_from_servers_list(self,servers_list,check=True): """ Initializes the dictionary using a list of server_names like ['Exec/Instance'] """ t0 = time.time() if type(servers_list) is str: servers_list = servers_list.split(',') if check: self.check_servers_names(servers_list) for s in servers_list: try: self.log.debug('loading from %s/%s server'%(get_tango_host(self.db),s)) ss=TServer(name=s,parent=self) ss.init_from_db(self.db) self[s] = ss except Exception,e: self.log.warning('exception loading %s server: %s' % (s,str(e)[:100]+'...')) print traceback.format_exc() self.log.debug('load_from_servers_list(%d) took %f seconds' % (len(servers_list),time.time()-t0)) return self
def __init__(self,use_tau = False, tango_host = ''): self.log = Logger('ProxiesDict') self.log.setLogLevel('INFO') self.use_tau = TAU and use_tau self.tango_host = tango_host self.call__init__(CaselessDefaultDict,self.__default_factory__)