def __init__(self, logger, cfg):
self.logger = logger
self.cfg = cfg
self.fv = ro.remoteObjectProxy('fitsview')
self.fv1 = ro.remoteObjectProxy('fitsview1')
self.stars = ro.remoteObjectProxy('STARS')
self.insconfig = INSconfig()
def __init__(self, logger, cfg):
self.logger = logger
self.cfg = cfg
self.tsc = ro.remoteObjectProxy('TSC')
self.status = ro.remoteObjectProxy('status')
# For doing pa/ma settings changes
self.pama = pama.PAMASettings(self.logger)
if pamafile and os.path.exists(pamafile):
self.pama.loadYAML(pamafile)
def client(logger, options, args):
import pyfits
if options.host:
auth = (options.svcname, options.svcname)
svc = ro.remoteObjectClient(options.host,
options.port,
name=options.svcname,
auth=auth)
else:
svc = ro.remoteObjectProxy(options.svcname)
if options.framelist:
# If --framelist=FILE was specified, then read FILE and make a
# list of fits files from it.
try:
in_f = open(options.framelist, 'r')
buf = in_f.read()
args = buf.split()
args = map(lambda fid: options.fitsdir + '/' + fid + '.fits', args)
except IOError, e:
raise DAQerror("Failed to open '%s': %s" %
(options.framelist, str(e)))
def main(options, args):
logname = 'sendlog'
logger = ssdlog.make_logger(logname, options)
ro.init()
tm = ro.remoteObjectProxy('taskmgr0')
tm.loadModule('LOGTask')
tm.addAllocs(['STARS'])
today = datetime.date.today()
one_day = datetime.timedelta(days=1)
yesterday = today - one_day
if not options.fromdate:
obs_time_from = '%s 17:00:00' % (yesterday)
day_time_from = '%s 08:00:00' % (yesterday)
else:
obs_time_from = options.fromdate
day_time_from = options.fromdate
if not options.todate:
obs_time_to = '%s 08:00:00' % (today)
day_time_to = '%s 17:00:00' % (yesterday)
else:
obs_time_to = options.todate
day_time_to = options.fromdate
try:
logdir = os.environ['LOGHOME']
except KeyError, e:
logdir = '/gen2/logs'
def __init__(self, interval=None, statusKeys=("TSCS.AZ", "TSCL.WINDD", "TSCL.WINDS_O"), size=DIRN_DEFAULTSIZE, mode=None, logger=None, parent=None):
super(Directions, self).__init__(parent)
self.setupUi(self, size=size)
self.wind_direction=0
self.subaru_az=0
self.wind_speed=0
self.logger=logger
self.statusKeys = statusKeys
if mode=='test':
interval=1000*interval # milli sec
self.logger.debug('setting interval %d' %interval )
timer_d = QTimer(self)
self.connect(timer_d, SIGNAL("timeout()"), self.fetch_fake_data)
self.logger.debug('timer connected to fetchData' )
timer_d.start(interval)
elif mode == 'solo':
ro.init()
#st.g2StatusObj('status')
self.status = ro.remoteObjectProxy('status')
interval=1000*interval # milli sec
self.logger.debug('setting interval %d' %interval )
timer_d = QTimer(self)
self.connect(timer_d, SIGNAL("timeout()"), self.fetch_solo_data)
self.logger.debug('timer connected to fetchData' )
timer_d.start(interval)
def setUp(self):
self.env = environment.MockEnvironment()
self.myhost = ro.get_myhost()
self.rohosts = []
self.ns = remoteObjectNameSvc.remoteObjectNameService(
self.rohosts,
name='remoteObjectNameServer',
host=self.myhost,
port=ro.nameServicePort)
self.ns.ro_start()
waitForService(self.ns, 'names')
#print "Hosts for",'names',self.ns.getHosts('names')
ro.init()
self.initval = 'init'
self.server = FakeServer(self.initval)
self.servicename = 'TestServiceName2'
self.ROserver = ro.remoteObjectServer(obj=self.server,
name=self.servicename,
svcname=self.servicename,
usethread=True)
self.ROserver.ro_start()
waitForService(self.ns, self.servicename)
#print "Hosts for",self.servicename,self.ns.getHosts(self.servicename)
self.ROclient = ro.remoteObjectProxy(self.servicename)
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
self.myhost = ro.get_myhost()
self.rohosts = []
self.ns = remoteObjectNameSvc.remoteObjectNameService(
self.rohosts,
name='remoteObjectNameServer',
host=self.myhost,
port=ro.nameServicePort)
self.ns.ro_start()
waitForService(self.ns, 'names')
#print "Status",self.ns.init0_up1_down2
#print "Hosts for",'names',self.ns.getHosts('names')
ro.init()
#time.sleep(1)
self.servicename = 'TestServiceName'
self.ROserver = FakeROServer(self.servicename, usethread=True)
self.ROserver.ro_start()
waitForService(self.ns, self.servicename)
#print "Hosts for",self.servicename,self.ns.getHosts(self.servicename)
self.ROclient = ro.remoteObjectProxy(self.servicename)
self.val1 = '1'
self.val2 = self.val1 + "22"
self.rofilename = self.env.INST_PATH + "/ROfilename"
def __init__(self,
logger,
monitor,
debug,
dummyval,
usethread,
ev_quit=None):
self.logger = logger
self.debug = debug # do dubug or not
self.monitor = monitor # do monitoring
self.dummyval = dummyval # use dummy fits values
self.usethread = usethread # use thread
self.timeout = 0.2 # Q timeout
self.cmd_end = "END"
self.aliasVal = guiderfitsheader.getAlias() # status alias values
self.keyVal = guiderfitsheader.getKeyVal()
# fits header template
self.guiderFitsHeader = guiderfitsheader.guider_fits_header
# set thread event
if not ev_quit: self.ev_quit = threading.Event()
else: self.ev_quit = ev_quit
# monitor instance
if self.monitor:
self.db = Monitor.Minimon('GuiderInt.mon', self.logger)
self.db.subscribe(self.monitor, ['GuiderInt'], None)
if not self.dummyval:
self.svc = ro.remoteObjectProxy('status')
def setAllocs(self, allocNames):
"""Set the list of allocations for the task manager. Given a list
of remote object service names, allocate proxies (handles) to all of
the remote objects and put them in the allocs list.
"""
allocs = {}
try:
for svcname in allocNames:
# Aliasing service under a different name?
if '=' in svcname:
(alias, svcname) = svcname.split('=')
else:
alias = svcname
if self.internal_allocs.has_key(svcname):
proxy = self.internal_allocs[svcname]
else:
proxy = ro.remoteObjectProxy(svcname)
allocs[alias] = proxy
except ro.remoteObjectError, e:
errmsg = "Error allocating subsystem: %s" % svcname
self.logger.error(errmsg)
raise TaskManagerError(errmsg)
def _getProxy(self, subscriber, options):
"""Internal method to create & cache remoteObject proxies to remote
pubsubs (subscribers).
"""
try:
# If we already have a proxy for the _svcname_, return it.
return self._proxyCache[subscriber]
except KeyError:
# Create a new proxy to the external pubsub and cache it
# Fill in possible authentication and security params
kwdargs = { 'timeout': self.remote_timeout }
#kwdargs = {}
if options.has_key('auth'):
kwdargs['auth'] = options['auth']
if options.has_key('secure'):
kwdargs['secure'] = options['secure']
# subscriber can be a service name or a host:port
if not (':' in subscriber):
proxy_obj = ro.remoteObjectProxy(subscriber, **kwdargs)
else:
(host, port) = subscriber.split(':')
port = int(port)
proxy_obj = ro.remoteObjectClient(host, port, **kwdargs)
self._proxyCache[subscriber] = proxy_obj
self.logger.debug("Created proxy for '%s'" % (subscriber))
return proxy_obj
def initialize(self, ocsint):
'''Initialize instrument.
'''
super(TSCCAM, self).initialize(ocsint)
# Grab my handle to the OCS interface.
self.ocs = ocsint
# Thread pool for autonomous tasks
self.threadPool = self.ocs.threadPool
# For task inheritance:
self.tag = 'TSCCAM'
self.shares = ['logger', 'ev_quit', 'threadPool']
# Used to format status buffer (item lengths must match definitions
# of status aliases on SOSS side in $OSS_SYSTEM/StatusAlias.pro)
statfmt = "%(status)-8.8s,%(mode)-8.8s,%(count)8d;"
# Register my status.
self.mystatus = self.ocs.addStatusTable('TSCC0001',
['status', 'mode', 'count'],
formatStr=statfmt)
# Establish initial status values
self.mystatus.status = 'ALIVE'
self.mystatus.mode = 'LOCAL'
self.mystatus.count = 0
# Will be set to periodic status task
self.status_task = None
# Thread-safe bunch for storing parameters read/written
# by threads executing in this object
self.param = Bunch.threadSafeBunch()
# Interval between status packets (secs)
self.param.status_interval = 60
ro.init()
self.g2status = ro.remoteObjectProxy('status')
self.bootmgr = ro.remoteObjectProxy('bootmgr')
# Simulation variables
self.el = 89.5
self.az = -90.0
def main(options, args):
logger = ssdlog.make_logger('test', options)
if options.mode == 'test':
print 'test mode'
feed_test_data()
mymon = None
else:
ro.init()
# make a name for our monitor
#myMonName = ('testmon-%d' % os.getpid())
myMonName = ('testmon')
# monitor channels we are interested in
channels = options.channels.split(',')
# Create a local monitor
mymon = Monitor.Monitor(myMonName, logger, numthreads=4)
# Startup monitor threadpool
mymon.start(wait=True)
# start_server is necessary if we are subscribing, but not if only
# publishing
mymon.start_server(wait=True)
# Make our callback functions
m = Make_cb(logger=logger, monitor=mymon)
# Subscribe our callback functions to the local monitor
mymon.subscribe_cb(m.anon_arr, channels)
try:
# subscribe our monitor to the central monitor hub
monitor = ro.remoteObjectProxy(options.monitor)
monitor.subscribe(myMonName, channels, ())
except:
logger.error("subscribe to the central monitor faild")
try:
app = QtGui.QApplication(sys.argv)
tv = TreeView()
tv.start_updating()
tv.show()
sys.exit(app.exec_())
stop_service(tv, mymon=mymon)
print 'GUI END'
except KeyboardInterrupt:
print 'Keyboard'
#gtk.main_quit()
stop_service(tv, mymon=mymon)
def stop_host(up, dn):
try:
svcname = ('g2disp-%s' % up.host.replace('.', '_'))
handle = ro.remoteObjectProxy(svcname)
handle.viewerOff(up.xdisp, up.geom)
handle.viewerOff(dn.xdisp, dn.geom)
except ro.remoteObjectError, e:
self.logger.error(
"Error stopping viewer on remote host '%s': %s" %
(up.host, str(e)))
def start(self):
# prefixes will be mon.session and mon.alloc
self.tagpfx = ('mon')
self.channels = monchannels
# For updating status system with session info
# TODO: parameterize object
self.status = ro.remoteObjectProxy('status')
# For starting interfaces
# TODO: parameterize object
self.bootmgr = ro.remoteObjectProxy('bootmgr')
# Try to restore previous session. If it fails, then create
# a new session.
try:
self.mon.restore()
except IOError, e:
self.initialize()
def main(options, args):
# Initialize remote objects service, necessary before any
ro.init()
svcname = options.svcname
auth = None
if options.auth:
auth = options.auth.split(':')
if options.server:
authDict = {}
if auth:
authDict[auth[0]] = auth[1]
print "Starting '%s' service..." % svcname
svc = MyRemoteService(svcname,
usethread=False,
authDict=authDict,
secure=options.secure,
cert_file=options.cert,
default_auth=False)
try:
# Start remote objects server. Since usethread=False
# in the constructor, we will block here until server
# exits.
svc.ro_start()
except KeyboardInterrupt:
print "Shutting down '%s' ..." % svcname
else:
# Create proxy object for service
svc = ro.remoteObjectProxy(svcname, auth=auth, secure=options.secure)
try:
i = options.count
while i > 0:
# Call remote method on service
try:
res = svc.search(1.0, 2.0, 3.0, 4.0)
print "(%5d) res=%s" % (i, str(res))
except ro.remoteObjectError, e:
print "Call error: %s" % (str(e))
i -= 1
if i > 0:
time.sleep(options.interval)
except KeyboardInterrupt:
print "Keyboard interrupt received!"
def main(options, args):
#logger = ssdlog.make_logger('checkstat', options)
ro.init()
st = ro.remoteObjectProxy(options.statussvc)
insdata = INSdata()
statusDict = {}
lookupDict = {}
# Get all the names of the 'ALIVE' status tables for the instruments
for insname in insdata.getNames():
if insname == 'VGW':
continue
inscode = insdata.getCodeByName(insname)
tblname = '%3.3sS0001' % inscode
alias = 'GEN2.STATUS.TBLTIME.%s' % tblname
statusDict[alias] = 0
lookupDict[alias] = insname
# Additional tables to check
for tblname in ('TSCS', 'TSCL', 'TSCV', 'VGWD', 'VGWQ'):
alias = 'GEN2.STATUS.TBLTIME.%s' % tblname
statusDict[alias] = 0
lookupDict[alias] = tblname
fetchDict = st.fetch(statusDict)
if options.sorttime:
times = fetchDict.items()
times.sort(_timecmp)
keys = [(alias, lookupDict[alias]) for alias in \
map(lambda x: x[0], times)]
else:
keys = lookupDict.items()
keys.sort(lambda x, y: cmp(x[1], y[1]))
#print keys
for alias, name in keys:
timeval = fetchDict[alias]
if timeval == '##NODATA##':
time_s = 'No record'
elif isinstance(timeval, float):
time_s = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(timeval))
else:
time_s = 'ERROR: %s' % str(timeval)
print "%-8.8s %s" % (name, time_s)
def rosh_conn(self, svcname, auth=None):
"""Connect to remote object service (svcname)"""
self.svc[svcname] = ro.remoteObjectProxy(svcname,
auth=auth)
try:
self.svc[svcname].ro_echo(1)
self.cursor = svcname
return svcname
except ro.remoteObjectError, e:
print str(e)
return None
def start_host(up, up_rmdsp, dn, dn_rmdsp, passwd, viewonly):
print "starting on host %s" % (up.host)
try:
svcname = ('g2disp-%s' % up.host.replace('.', '_'))
handle = ro.remoteObjectProxy(svcname)
handle.viewerOn(up.xdisp, up.geom, up_rmdsp, passwd, viewonly)
handle.viewerOn(dn.xdisp, dn.geom, dn_rmdsp, passwd, viewonly)
except ro.remoteObjectError, e:
self.logger.error(
"Error starting viewer on remote host '%s': %s" %
(up.host, str(e)))
def main(options, args):
ro.init()
insconfig = INSdata()
archiver = ro.remoteObjectProxy('archiver')
if options.infile:
with open(options.infile, 'r') as in_f:
buf = in_f.read()
else:
buf = sys.stdin.read()
for line in buf.split('\n'):
line = line.strip()
# skip blank lines and comments
if (len(line) == 0) or line.startswith('#'):
continue
(frameid, path) = line.split()
if ':' in path:
host, path = path.split(':')
else:
host = None
finfo = frame.getFrameInfoFromPath(frameid)
# TODO: we could do in groups, would be faster if there are
# a lot of files to transfer
framelist = [(finfo.frameid, path)]
# Look up the instrument transfer info
obcpinfo = insconfig.getOBCPInfoByCode(finfo.inscode)
if not host:
host = obcpinfo['obcphost']
transfermethod = obcpinfo['transfermethod']
# Make a call to the archiver to transfer this file
print "Attempting to archive %s: %s" % (frameid, path)
if not options.dry_run:
res = archiver.archive_framelist(host, transfermethod, framelist)
if res != ro.OK:
print "Archiver returned error code %d" % (res)
else:
print "Archived file."
time.sleep(options.interval)
else:
print "Host: %s Method: %s Framelist: %s" % (host, transfermethod,
str(framelist))
def __init__(self, options, logger):
"""Constructor for the INSintTester object.
"""
# Invoke our base class constructor.
INSintGUI.__init__(self)
self.logger = logger
self.insconfig = INSconfig()
# Set up default connection parameters from command line
self.obcpnum = options.obcpnum
self.monunitnum = options.monunitnum
if not options.obcphost:
self.obcphost = SOSSrpc.get_myhost(short=True)
else:
self.obcphost = options.obcphost
self.raidpath = options.fitsdir
self.transfermethod = options.transfermethod
self.username = options.username
self.password = options.password
self.ev_quit = threading.Event()
self.ev_mainquit = threading.Event()
self.soss = None
# Did user specify a Gen2 status source?
if options.statussvc:
ro_status = ro.remoteObjectProxy(options.statussvc)
statusObj = INSint.FetchStatusWrapper_Gen2(ro_status)
# Did user specify a SOSS status source?
elif options.statushost:
from SOSS.status import cachedStatusObj
statusDict = cachedStatusObj(options.statushost)
statusObj = INSint.FetchStatusWrapper_SOSS(statusDict)
# Did user specify a SOSS status file?
elif options.statusfile:
try:
in_f = open(options.statusfile, 'r')
statusDict = eval(in_f.read())
in_f.close()
except Exception, e:
self.showStatus("Error reading status file '%s': %s" % \
(options.statusfile, str(e)))
statusDict = {}
statusObj = INSint.FetchStatusWrapper_SOSS(statusDict)
def __init__(self, svcname, debug, port, usethread=False):
# Superclass constructor
#self.guider=GuiderSaveFrame(debug=False, monitor=monitor, svcname=svcname)
ro.remoteObjectServer.__init__(self,
svcname=svcname,
port=port,
usethread=usethread)
self.debug = debug
#self.monitor=monitor
self.image = None
self.status = ro.remoteObjectProxy('status')
def main(options, args):
# Initialize remote objects service, necessary before any
ro.init()
svcname = options.svcname
auth = None
if options.auth:
auth = options.auth.split(':')
if options.server:
authDict = {}
if auth:
authDict[auth[0]] = auth[1]
print "Starting '%s' service..." % svcname
svc = MyRemoteService(svcname, usethread=False, authDict=authDict,
secure=options.secure, cert_file=options.cert,
default_auth=False)
try:
# Start remote objects server. Since usethread=False
# in the constructor, we will block here until server
# exits.
svc.ro_start()
except KeyboardInterrupt:
print "Shutting down '%s' ..." % svcname
else:
# Create proxy object for service
svc = ro.remoteObjectProxy(svcname, auth=auth, secure=options.secure)
try:
i = options.count
while i > 0:
# Call remote method on service
try:
res = svc.search(1.0, 2.0, 3.0, 4.0)
print "(%5d) res=%s" % (i, str(res))
except ro.remoteObjectError, e:
print "Call error: %s" % (str(e))
i -= 1
if i > 0:
time.sleep(options.interval)
except KeyboardInterrupt:
print "Keyboard interrupt received!"
def __init__(self, logger):
starsdb = STARSdb(logger)
self.isSTARS = starsdb.is_log_stars
ro.init()
self.tm = ro.remoteObjectProxy('taskmgr0')
self.tm.loadModule('LOGTask')
self.tm.addAllocs(['STARS'])
self.sendcmd_tpl = 'EXEC LOG Send_Log logpath="%s" indexdir="%s" name=%s logstarttime="%s" logendtime="%s" '
self.removecmd_tpl = 'EXEC LOG Remove_Log logpath="%s"'
self.logger = logger
def __init__(self, svcname, logger, monitor=None, monchannels=[]):
self.logger = logger
self.monitor = monitor
self.monchannels = monchannels
# TODO: parameterize tag template (from svcname?)
self.tag_template = 'mon.frame.%s.frameSvc'
self.insconfig = INSconfig()
# For updating status system with session info
# TODO: parameterize object
self.status = ro.remoteObjectProxy('status')
# For mutual exclusion
self.lock = threading.RLock()
def main(options, args):
logname = 'deletelog'
logger = ssdlog.make_logger(logname, options)
starsdb = STARSdb(logger)
isSTARS = starsdb.is_log_stars
ro.init()
tm = ro.remoteObjectProxy('taskmgr0')
tm.loadModule('LOGTask')
tm.addAllocs(['STARS'])
try:
logdir = os.environ['LOGHOME']
except KeyError, e:
logdir = '/gen2/logs'
def on_setup_clicked(self, widget):
sw = self.widgets['dialog_setup']
# Set other fields to defaults
self.on_location_changed(widget)
sw.window.show()
resp = sw.run()
sw.window.hide()
if resp == gtk.RESPONSE_OK:
starshost = self.widgets['starshost'].get_text()
if starshost == 'N/A':
starshost = None
self.starshost = starshost
starsdir = self.widgets['starsdir'].get_text()
if starsdir == 'N/A':
starsdir = None
self.starsdir = starsdir
channels = self.widgets['channels'].get_text()
channels = map(int, channels.split(','))
for ch_i in channels:
if not ch_i in [1, 2, 3, 4, 5, 6, 7, 8]:
self.showStatus("Channels must be in the range 1-8!!")
return gtk.TRUE
self.channels = channels
db = StatusBundle.nestedStatusBundle()
if self.monitor:
monitor = ro.remoteObjectProxy(self.monitor)
svcname = 'STARSint'
db.register_sync(svcname, monitor)
# Any way to force collection of the socket here?
self.stars = None
try:
self.stars = STARSinterface(starshost=self.starshost,
starsdir=self.starsdir,
channels=self.channels,
db=db,
ev_quit=self.ev_quit)
except Exception, e:
self.showStatus("FAILED TO INITIALIZE INTERFACE")
self.stars = None
def client(options, data, is_binary):
datafile = None
if options.datafile:
datafile = open(options.datafile, 'a')
auth = None
if options.auth:
auth = options.auth.split(':')
# Get handle to server
testro = ro.remoteObjectProxy(options.svcname,
auth=auth,
secure=options.secure)
print "Starting '%s' client..." % (options.svcname)
size = len(data)
time1 = time.time()
if is_binary:
data = ro.binary_encode(data)
time2 = time.time()
amount = 0.0
for i in xrange(options.count):
res = testro.recv(data, is_binary)
amount += size
tottime = time.time() - time1
# Average time if more than one call made
if options.count > 1:
tottime = tottime / options.count
print "Time taken: %f secs (%f bytes/sec) (enc: %f secs) " % \
(tottime, amount/tottime, time2-time1)
if datafile:
# total bytes, count, total time, encode time, avg rate
datafile.write("%d %d %f %f %f\n" %
(size * options.count, options.count, tottime,
time2 - time1, amount / tottime))
datafile.close()
def build_gui(self, container):
self.firstTime = True
self.root = container
self.aliases = []
self.previousStatusDict = None
# Set up a connection to the alarm_handler so that the GUI can
# send messages to it
self.alhProxy = ro.remoteObjectProxy('alarm_handler')
layout = QtGui.QVBoxLayout()
layout.setContentsMargins(4, 4, 4, 4)
layout.setSpacing(4)
container.setLayout(layout)
# Create the GUI from the MainWindow class in alarm_gui.py
self.mw = AlarmGui.MainWindow('', self.alhProxy, self.logger,
container)
layout.addWidget(self.mw, stretch=1)
def resend(options, logger, files):
# Second pass. Resend files NOT in STARS.
logger.info("Cleanup PASS 2: resend files.")
# initialize remoteObjects and get a handle to the STARS interface
ro.init()
stars = ro.remoteObjectProxy('STARS')
for fitsfile in files:
fitspath = os.path.join(options.fitsdir, fitsfile)
logger.info("File '%s' NOT in STARS--resending..." % fitsfile)
try:
if not options.dry_run:
stars.resend_fits(fitspath)
time.sleep(options.interval)
except Exception, e:
logger.error("Error resending %s: %s" % (fitsfile, str(e)))
def decode_abscmd(cmdstr, envstr, sk_bank, logger):
import remoteObjects as ro
ro.init()
fakeStatus = {
'STATL.TSC_F_SELECT': 'CS_IR',
}
# Create top level logger.
logger = ssdlog.make_logger('sk_decode', options)
sk_bank = skBank(options.skdir, logger=logger)
variable_resolver = VariableResolver({})
register_resolver = RegisterResolver()
#status_resolver = MockStatusResolver(fakeStatus)
status_resolver = StatusResolver(ro.remoteObjectProxy('status'))
frame_source = MockFrameSource()
eval = Evaluator(variable_resolver, register_resolver, status_resolver,
frame_source, logger)
# Parse environment string into an AST, raising parse error if
# necessary
envstr = envstr.strip()
if len(envstr) > 0:
res = sk_bank.parser.parse_params(envstr)
if res[0]:
raise DecodeError("Error parsing default parameters '%s': %s" %
(envstr, res[2]))
try:
ast_global_params = res[1]
assert ast_global_params.tag == 'param_list', ASTerr(
ast_global_params)
except AssertionError, e:
raise DecodeError("Malformed default parameter list '%s': AST=%s" %
(envstr, str(ast_global_params)))
def client2(options):
datafile = None
if options.datafile:
datafile = open(options.datafile, 'a')
auth = None
if options.auth:
auth = options.auth.split(':')
# Get handle to server
testro = ro.remoteObjectProxy(options.svcname,
auth=auth,
secure=options.secure,
timeout=2.0)
time1 = time.time()
for i in xrange(options.count):
res = testro.search(1.0, 2.0, 3.0, 4.0)
if options.interval:
time.sleep(options.interval)
tottime = time.time() - time1
time_per_call = tottime / options.count
calls_per_sec = int(1.0 / time_per_call)
print "Time taken: %f secs total %f sec per call %d calls/sec" % \
(tottime, time_per_call, calls_per_sec)
if datafile:
# total bytes, count, total time, encode time, avg rate
datafile.write("%d %d %f %f %f\n" %
(size * options.count, options.count, tottime,
time2 - time1, amount / tottime))
datafile.close()
