def __init__(self,
appid='meqserver',
client_id='meqclient',
spawn=None,
opt=False,
**kwargs):
if spawn and isinstance(spawn, bool):
if opt:
spawn = default_spawn_opt
else:
spawn = default_spawn
# set gui arg
if 'gui' in kwargs and kwargs['gui'] and not callable(kwargs['gui']):
kwargs['gui'] = meqserver_gui
self._we_track_results = None
# init base class
multiapp_proxy.__init__(self, appid, client_id, spawn=spawn, **kwargs)
# setup own state
self._pprint = PrettyPrinter(width=78, stream=sys.stderr)
# track axis map changes
self._we_axis_list = self.whenever('axis.list',
self._axis_list_handler)
# if base/gui init() has explicitly disabled result tracking, _we_track_results
# will be False rather than None
if self.get_verbose() > 0 and self._we_track_results is None:
self.dprint(1, 'verbose>0: auto-enabling node_result output')
self.track_results(True)
self.dprint(
1, 'you can disable this by calling .track_results(False)')
def set_data(self, dataitem, default_open=None, **opts):
_dprint(3, 'set_data ', dataitem.udi)
# save currently open tree
if self._rec is not None:
openitems = self.get_open_items()
else: # no data, use default open tree if specified
openitems = default_open or self._default_open
# clear everything and reset data as new
self.clear()
self.set_udi_root(dataitem.udi)
self._rec = dataitem.data
self._pprint = PrettyPrinter(width=78, stream=sys.stderr)
self.set_refresh_func(dataitem.refresh_func)
# expand first level of record
self.set_content(self._rec)
# apply saved open tree
self.set_open_items(openitems)
# enable & highlight the cell
self.enable()
self.flash_refresh()
def __init__(self,appid='meqserver',client_id='meqclient',
spawn=None,opt=False,**kwargs):
if spawn and isinstance(spawn,bool):
if opt:
spawn = default_spawn_opt;
else:
spawn = default_spawn;
# set gui arg
if 'gui' in kwargs and kwargs['gui'] and not callable(kwargs['gui']):
kwargs['gui'] = meqserver_gui;
self._we_track_results = None;
# init base class
multiapp_proxy.__init__(self,appid,client_id,spawn=spawn,**kwargs);
# setup own state
self._pprint = PrettyPrinter(width=78,stream=sys.stderr);
# track axis map changes
self._we_axis_list = self.whenever('axis.list',self._axis_list_handler);
# if base/gui init() has explicitly disabled result tracking, _we_track_results
# will be False rather than None
if self.get_verbose() > 0 and self._we_track_results is None:
self.dprint(1,'verbose>0: auto-enabling node_result output');
self.track_results(True);
self.dprint(1,'you can disable this by calling .track_results(False)');
class meqserver(multiapp_proxy):
"""interface to MeqServer app"""
def __init__(self,
appid='meqserver',
client_id='meqclient',
spawn=None,
opt=False,
**kwargs):
if spawn and isinstance(spawn, bool):
if opt:
spawn = default_spawn_opt
else:
spawn = default_spawn
# set gui arg
if 'gui' in kwargs and kwargs['gui'] and not callable(kwargs['gui']):
kwargs['gui'] = meqserver_gui
self._we_track_results = None
# init base class
multiapp_proxy.__init__(self, appid, client_id, spawn=spawn, **kwargs)
# setup own state
self._pprint = PrettyPrinter(width=78, stream=sys.stderr)
# track axis map changes
self._we_axis_list = self.whenever('axis.list',
self._axis_list_handler)
# if base/gui init() has explicitly disabled result tracking, _we_track_results
# will be False rather than None
if self.get_verbose() > 0 and self._we_track_results is None:
self.dprint(1, 'verbose>0: auto-enabling node_result output')
self.track_results(True)
self.dprint(
1, 'you can disable this by calling .track_results(False)')
# define meqserver-specific methods
def meq(self, command, args=None, wait=None, silent=False):
"""sends a meq-command and optionally waits for result.
wait can be specified in seconds, or True to wait indefinitely."""
command = make_hiid(command)
payload = record()
if args is not None:
payload.args = args
# send command and wait for reply
if wait:
if isinstance(wait, bool):
wait = None
# timeout=None means block indefinitely
if silent:
self.dprint(
0,
'warning: both wait and silent specified, ignoring silent flag'
)
payload.command_index = self.new_command_index()
replyname = 'result' + command + payload.command_index
self.dprintf(3, 'sending command %s with wait\n', command)
self.dprint(5, 'arguments are ', args)
self.pause_events()
self.send_command('command' + command, payload)
msg = self. await (replyname, resume=True, timeout=wait)
return msg.payload
# else simply send command
else:
self.dprintf(3, 'sending command %s with no wait, silent=%d\n',
command, silent)
self.dprint(5, 'arguments are ', args)
payload.silent = silent
self.send_command('command' + command, payload)
# helper function to create a node specification record
def makenodespec(self, node):
"makes an record( containing a node specification"
if isinstance(node, str):
return record(name=node)
elif isinstance(node, int):
return record(nodeindex=node)
else:
raise TypeError('node must be specified by name or index, have ' +
str(type(node)))
def createnode(self, initrec, wait=False, silent=False):
initrec = make_record(initrec)
return self.meq('Create.Node', initrec, wait=wait, silent=silent)
def getnodestate(self, node, wait=True, sync=False):
spec = self.makenodespec(node)
spec.sync = sync
return self.meq('Node.Get.State', spec, wait=wait)
def setnodestate(self, node, fields_record, wait=False, sync=True):
spec = self.makenodespec(node)
spec.sync = sync
spec.state = fields_record
return self.meq('Node.Set.State', spec, wait=wait)
def getnodeindex(self, name):
retval = self.meq('Get.NodeIndex', self.makenodespec(name), wait=True)
try:
return retval.nodeindex
except:
raise ValueError('MeqServer did not return a nodeindex field')
def getnodelist(self,
name=True,
nodeindex=True,
classname=True,
children=False):
rec = record({
'name': name,
'nodeindex': nodeindex,
'class': classname,
'children': children
})
return self.meq('Get.Node.List', rec, wait=True)
def execute(self, node, req, wait=False):
rec = self.makenodespec(node)
rec.request = req
return self.meq('Node.Execute', rec, wait=wait)
def clearcache(self, node, recursive=True, wait=False, sync=True):
rec = self.makenodespec(node)
rec.recursive = recursive
rec.sync = sync
return self.meq('Node.Clear.Cache', rec, wait=wait)
def change_wd(self, path):
rec = record(cwd=path)
return self.meq('Set.Cwd', rec, wait=False)
def publish(self, node, wait=False):
rec = self.makenodespec(node)
rec.level = 1
return self.meq('Node.Set.Publish.Level', rec, wait=wait)
def _event_handler(self, msg):
"""Auguments app_proxy._event_handler(), to keep track of forest state"""
multiapp_proxy._event_handler(self, msg)
payload = msg.payload
if self.current_server \
and getattr(msg,'from') == self.current_server.addr \
and isinstance(payload,record):
# check if message includes update of forest state and/or status
fstatus = getattr(payload, 'forest_status', None)
fstate = getattr(payload, 'forest_state', None)
# update forest state, if supplied. Merge in the forest status if
# we also have it
if fstate is not None:
if fstatus is not None:
fstate.update(fstatus)
meqds.update_forest_state(fstate)
# no forest state supplied but a status is: merge it in
elif fstatus is not None:
meqds.update_forest_state(fstatus, merge=True)
def _result_handler(self, msg):
try:
value = msg.payload
dprint(0, '============= result for node: ', value.name)
self._pprint.pprint(value)
except:
print('exception in meqserver._result_handler: ', sys.exc_info())
traceback.print_exc()
def _axis_list_handler(self, msg):
try:
if self.current_server \
and getattr(msg,'from') == self.current_server.addr: \
mequtils.set_axis_list(msg.payload)
except:
print('exception in meqserver._axis_list_handler: ',
sys.exc_info())
traceback.print_exc()
def track_results(self, enable=True):
if enable:
self.dprint(2, 'auto-printing all node_result events')
if self._we_track_results:
self._we_track_results.activate()
else:
self._we_track_results = self.whenever('node.result',
self._result_handler)
else: # disable
self.dprint(2, 'disabling auto-printing of node_result events')
if self._we_track_results:
self._we_track_results.deactivate()
self._we_track_results = False
class meqserver (multiapp_proxy):
"""interface to MeqServer app""";
def __init__(self,appid='meqserver',client_id='meqclient',
spawn=None,opt=False,**kwargs):
if spawn and isinstance(spawn,bool):
if opt:
spawn = default_spawn_opt;
else:
spawn = default_spawn;
# set gui arg
if 'gui' in kwargs and kwargs['gui'] and not callable(kwargs['gui']):
kwargs['gui'] = meqserver_gui;
self._we_track_results = None;
# init base class
multiapp_proxy.__init__(self,appid,client_id,spawn=spawn,**kwargs);
# setup own state
self._pprint = PrettyPrinter(width=78,stream=sys.stderr);
# track axis map changes
self._we_axis_list = self.whenever('axis.list',self._axis_list_handler);
# if base/gui init() has explicitly disabled result tracking, _we_track_results
# will be False rather than None
if self.get_verbose() > 0 and self._we_track_results is None:
self.dprint(1,'verbose>0: auto-enabling node_result output');
self.track_results(True);
self.dprint(1,'you can disable this by calling .track_results(False)');
# define meqserver-specific methods
def meq (self,command,args=None,wait=None,silent=False):
"""sends a meq-command and optionally waits for result.
wait can be specified in seconds, or True to wait indefinitely.""";
command = make_hiid(command);
payload = record();
if args is not None:
payload.args = args;
# send command and wait for reply
if wait:
if isinstance(wait,bool):
wait = None; # timeout=None means block indefinitely
if silent:
self.dprint(0,'warning: both wait and silent specified, ignoring silent flag');
payload.command_index = self.new_command_index();
replyname = 'result' + command + payload.command_index;
self.dprintf(3,'sending command %s with wait\n',command);
self.dprint(5,'arguments are ',args);
self.pause_events();
self.send_command('command'+command,payload);
msg = self.await(replyname,resume=True,timeout=wait);
return msg.payload;
# else simply send command
else:
self.dprintf(3,'sending command %s with no wait, silent=%d\n',command,silent);
self.dprint(5,'arguments are ',args);
payload.silent = silent;
self.send_command('command'+command,payload);
# helper function to create a node specification record
def makenodespec (self,node):
"makes an record( containing a node specification";
if isinstance(node,str):
return record(name=node);
elif isinstance(node,int):
return record(nodeindex=node);
else:
raise TypeError,'node must be specified by name or index, have '+str(type(node));
def createnode (self,initrec,wait=False,silent=False):
initrec = make_record(initrec);
return self.meq('Create.Node',initrec,wait=wait,silent=silent);
def getnodestate (self,node,wait=True,sync=False):
spec = self.makenodespec(node);
spec.sync = sync;
return self.meq('Node.Get.State',spec,wait=wait);
def setnodestate (self,node,fields_record,wait=False,sync=True):
spec = self.makenodespec(node);
spec.sync = sync;
spec.state = fields_record;
return self.meq('Node.Set.State',spec,wait=wait);
def getnodeindex (self,name):
retval = self.meq('Get.NodeIndex',self.makenodespec(name),wait=True);
try: return retval.nodeindex;
except:
raise ValueError,'MeqServer did not return a nodeindex field';
def getnodelist (self,name=True,nodeindex=True,classname=True,children=False):
rec = record({'name':name,'nodeindex':nodeindex,'class':classname,'children':children});
return self.meq('Get.Node.List',rec,wait=True);
def execute (self,node,req,wait=False):
rec = self.makenodespec(node);
rec.request = req;
return self.meq('Node.Execute',rec,wait=wait);
def clearcache (self,node,recursive=True,wait=False,sync=True):
rec = self.makenodespec(node);
rec.recursive = recursive;
rec.sync = sync;
return self.meq('Node.Clear.Cache',rec,wait=wait);
def change_wd (self,path):
rec = record(cwd=path);
return self.meq('Set.Cwd',rec,wait=False);
def publish (self,node,wait=False):
rec = self.makenodespec(node);
rec.level = 1;
return self.meq('Node.Set.Publish.Level',rec,wait=wait);
def _event_handler (self,msg):
"""Auguments app_proxy._event_handler(), to keep track of forest state""";
multiapp_proxy._event_handler(self,msg);
payload = msg.payload;
if self.current_server \
and getattr(msg,'from') == self.current_server.addr \
and isinstance(payload,record):
# check if message includes update of forest state and/or status
fstatus = getattr(payload,'forest_status',None);
fstate = getattr(payload,'forest_state',None);
# update forest state, if supplied. Merge in the forest status if
# we also have it
if fstate is not None:
if fstatus is not None:
fstate.update(fstatus);
meqds.update_forest_state(fstate);
# no forest state supplied but a status is: merge it in
elif fstatus is not None:
meqds.update_forest_state(fstatus,merge=True);
def _result_handler (self,msg):
try:
value = msg.payload;
dprint(0,'============= result for node: ',value.name);
self._pprint.pprint(value);
except:
print 'exception in meqserver._result_handler: ',sys.exc_info();
traceback.print_exc();
def _axis_list_handler (self,msg):
try:
if self.current_server \
and getattr(msg,'from') == self.current_server.addr: \
mequtils.set_axis_list(msg.payload);
except:
print 'exception in meqserver._axis_list_handler: ',sys.exc_info();
traceback.print_exc();
def track_results (self,enable=True):
if enable:
self.dprint(2,'auto-printing all node_result events');
if self._we_track_results:
self._we_track_results.activate();
else:
self._we_track_results = self.whenever('node.result',self._result_handler);
else: # disable
self.dprint(2,'disabling auto-printing of node_result events');
if self._we_track_results:
self._we_track_results.deactivate();
self._we_track_results = False;
