fandango.scripts.servers_lite module

fandango.scripts.servers_lite.Astor

alias of ServersDict

class fandango.scripts.servers_lite.CaselessDefaultDict

Bases: fandango.scripts.servers_lite.defaultdict_fromkey, taurus.core.util.containers.CaselessDict

a join venture between caseless and default dict This class merges the two previous ones. This declaration equals to:

CaselessDefaultDict = type(‘CaselessDefaultType’,(CaselessDict,defaultdict_fromkey),{})

class fandango.scripts.servers_lite.ProxiesDict

Bases: fandango.scripts.servers_lite.CaselessDefaultDict, taurus.core.util.object.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()()

get(dev_name)

get_admin(dev_name)

Adds to the dictionary the admin device for a given device name and returns a proxy to it.

pop(dev_name)

Removes a device from the dict

class fandango.scripts.servers_lite.ServersDict(pattern='', klass='', devs_list='', servers_list='', hosts='', loadAll=False, tango_host='')

Bases: taurus.core.util.containers.CaselessDict, taurus.core.util.object.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>

check_servers_names(servers_list)

Crosschecks the name of servers (case sensitive) with names retrieved by self.db.get_server_list()

create_new_server(server_name, class_name, devs_list)

It creates a new server in the database, using Jive’s like input.

get_all_classes()

It returns all classes appearing in servers.

get_all_devices()

It returns all devices contained in servers.

get_all_hosts()

It returns all hosts containing servers.

get_class_devices(klass)

This method gets the devices related to a Class.

get_class_servers(klass)

This method gets the servers related to a Class.

get_class_tree()

@todo It returns a dictionary with the shape {‘class’:{‘server’:’device’}}

get_db_device()

It creates a proxy to a dbserver device declared inside sys/database/* branch of Tango database.

get_device_class(device, server='')

This method gets the server related to a device; if it is not in the dict gets it from the Database.

get_device_host(device)

This method gets the server related to a device; if it is not in the dict gets it from the Database.

get_device_server(device)

This method gets the server related to a device; if it is not in the dict gets it from the Database.

get_device_tree()

@todo It returns a dictionary with the shape {‘server’:{‘class’:’device’}}

get_devs_from_db(dev_name)

Using a PyTango.Database object returns a list of all devices matching the given name (domain*/family*/member*)

get_host_level_servers(host, level=0, controlled=True)

It inspects all pre-loaded servers and returns those controlled in the specified host and level.

get_host_overview(host='')

Returns a dictionary with astor-like information @param host the host to display @return {‘level’:{‘server’:{‘device’:State}}}

get_host_servers(host)

It inspects all pre-loaded servers and returns those controlled in the specified host.

get_hosts_from_db(filt='*')

Using a PyTango.Database proxy returns a list with all registered hosts in database.

get_report()

def server_Report(self): The status of Servers

get_server_level(server_name)

It executes a DbGetServerInfo command in dbserver device.

get_server_states(update=False)

get_server_tree()

@todo It returns a dictionary with the shape {‘server’:{‘class’:’device’}}

kill_os(name)

kill_servers(servers_list)

Kills a list of SERVERs by sending a HardKillServer to the Starter of their hosts.

load_all_servers()

It loads all device servers declared in Tango database

load_by_host(host)

Initializes the dict with all the servers assigned to a given host.

load_by_name(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.

load_from_devs_list(devs_list)

Initializes the dict using a list of devices; a query to the database is used to identify the server for each device.

load_from_servers_list(servers_list, check=True)

Initializes the dictionary using a list of server_names like [‘Exec/Instance’]

refresh(servers=[], class_type='', asynch=True, timeout=60.0)

Updates states for given servers or the given class or all states if no class is given. The asynch argument controls if the state test is done in a separate thread for each server or not.

reset_server_level(server_name)

It sets host = ‘’, mode = 0, level = 0

restart_servers(servers_list=None, wait=5.0)

Performs stop_servers followed by start_servers.

set_server_level(server_name, host, level)

It executes a DbPutServerInfo command in dbserver device.

start_all_servers()

start_servers(servers_list=None, host='', wait=10.0)

def server_Start(self,servers_list,host=’‘,wait=3): Starting a list of servers or a single one in the given host(argument could be an string or a list) The wait parameter forces to wait several seconds until the device answers to an State command. wait=0 performs no wait

states(servers=[], class_type='', asynch=True, timeout=60.0)

Updates states for given servers or the given class or all states if no class is given. The asynch argument controls if the state test is done in a separate thread for each server or not.

stop_all_servers()

stop_servers(servers_list=None)

def server_Stop(self,dev_name): Stops a list of SERVERs by sending a Kill command to the admin device server. If the argument is a single device it will kill all the devices running in the same server!

update_states(servers=[], class_type='', asynch=True, timeout=60.0)

Updates states for given servers or the given class or all states if no class is given. The asynch argument controls if the state test is done in a separate thread for each server or not.

class fandango.scripts.servers_lite.TServer(name='', host='', parent=None)

Bases: taurus.core.util.object.Object

Class used by ServerDict to manage TangoDeviceServer admin devices.

classes

get_admin()

get_admin_name()

Returns the name of the server in the dserver/Server/Instance format.

get_all_states()

Returns a dictionary with the individual states of the inner devices.

get_all_status()

Returns a dictionary with the individual status of the inner devices.

get_classes(load=False)

get_device(device)

get_device_list()

Returns a list of devices declared for this server.

get_proxy(device='')

Returns a proxy to the given device; or the admin device if no device name is provided.

get_server_level()

It returns initialized values, does not get values from database.

get_simple_name(name='')

Returns the name of the server in the Server/Instance format.

get_starter_name()

Returns the starter on charge of controlling this server.

init_from_db(db=None, load_devices=False)

Gets name, classes, devices, host, level information from Tango Database.

ping(dname=None)

Executes .ping() and .state() methods of the admin device.

set_state(state)

update_level(host, level=0)

It only initializes the values, does not get values from database.

fandango.scripts.servers_lite.add_new_device(server, klass, device)

It can be used create any device, e.g. to create Starter in an init script add_new_device(‘Starter/$HOST’,’Starter’,’sys/admin/starter’)

Then:

./Starter $HOST &

fandango.scripts.servers_lite.clean_device_attribute_properties(device)

fandango.scripts.servers_lite.clean_device_properties(device)

class fandango.scripts.servers_lite.defaultdict_fromkey

Bases: collections.defaultdict

Creates a dictionary with a default_factory function that creates new elements using key as argument. Usage : new_dict = defaultdict_fromkey(method); where method like (lambda key: return new_obj(key)) Each time that new_dict[key] is called with a key that doesn’t exist, method(key) is used to create the value Copied from PyAlarm device server @deprecated now in tau.core.utils.containers

fandango.scripts.servers_lite.get_database()

fandango.scripts.servers_lite.get_database_device()

fandango.scripts.servers_lite.get_device(device)

fandango.scripts.servers_lite.get_device_attribute_properties(device, attribute)

fandango.scripts.servers_lite.get_device_attributes(device)

fandango.scripts.servers_lite.get_device_properties(device, flt='*')

fandango.scripts.servers_lite.get_device_property(device, property)

It returns device property value or just first item if value list has lenght==1

fandango.scripts.servers_lite.put_device_property(device, property, value=None)

Two syntax are possible:

• put_device_property(device,{property:value})
• put_device_property(device,property,value)

fandango.scripts.servers_lite.remove_device_server(server, clean_db=True)