def _start_mdsip(self, server, port, logname, protocol=MDSIP_PROTOCOL):
if port > 0:
from subprocess import Popen, STDOUT
logfile = '%s-%s%d.log' % (self.module, logname, self.index)
log = open(logfile, 'w') if iswin else None
try:
hosts = '%s/mdsip.hosts' % self.root
params = [
'mdsip', '-s', '-p',
str(port), '-P', protocol, '-h', hosts
]
print(' '.join(params + ['&>', logfile]))
if not log:
params.extend(['2>&1', '|', 'tee', logfile])
mdsip = Popen(params)
except:
if log:
log.close()
raise
try:
self._waitIdle(server, 10) # allow mdsip to launch
except Exception:
mdsip.kill()
raise
else:
mdsip, log = None, None
if server:
c = Connection(server)
for envpair in self.envx.items():
checkStatus(c.get('setenv($//"="//$)', *envpair))
c.get('tcl($)', 'set verify')
return mdsip, log
def run(self, jobset, skip_init):
import MDSplus
from MDSplus import Connection
self.error = []
jobs, names = jobset
self.r = {}
self.r['error message'] = ['']
try:
for k, job in enumerate(jobs):
for j in job:
if j.command == 'connection_mode':
if self.connection_str != j.params[0]:
self.connection_str = j.params[0]
server, port, tree = parse_server_string(
self.connection_str)
self.use_mdsconnect = (False if server.upper()
== 'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
try:
if port != '':
server = server + ':' + port
self.connection = Connection(server)
res = 'ok'
except:
res = ('connection error' +
traceback.format_exc())
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
res = self._run_job_mdsconnect(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
self.r['error message'] = self.error
return self.r
def loadpaths(host, treename):
"""Get the path environment variables for a tree being served by a remote system and
define them in this process context. The remote system's getpaths function is responsible
for fixing up the tree_path values, prefixing hostnames and replacing any shortened hostnames
with fully qualified ip address names."""
from MDSplus import Connection
import os
c = Connection(host)
paths = c.get("getpaths('%s')" % treename).deserialize()
for i in range(len(paths['path'])):
os.environ[paths['tree'][i].rstrip().lower() +
'_path'] = paths['path'][i].rstrip()
def io(self):
connection = Connection("thread://io")
""" mdsconnect """
self.assertEqual(connection.get('_a=1').tolist(), 1)
self.assertEqual(connection.get('_a').tolist(), 1)
self.assertEqual(connection.getObject('1:3:1').__class__, Range)
g = GetMany(connection)
g.append('a', '1')
g.append('b', '$', 2)
g.append('c', '$+$', 1, 2)
g.execute()
self.assertEqual(g.get('a'), 1)
self.assertEqual(g.get('b'), 2)
self.assertEqual(g.get('c'), 3)
def read_EAST_TS(shot):
from MDSplus import Connection as CN
conn = CN('202.127.204.12')
conn.openTree('analysis', shot)
R = conn.get('\\' + 'R_coreTS ').copy()
Z = conn.get('\\' + 'Z_coreTS ').copy()
time = conn.get('dim_of(' + '\\' + 'Te_maxTS' + ')').copy()
Te = conn.get('\\' + 'Te_coreTS ').copy()
Ne = conn.get('\\' + 'ne_coreTS').copy()
conn.closeAllTrees()
return R, Z, time, Te, Ne
class remoteTree(_mds.Tree):
def __init__(self, shot='-1', tree='W7X', server='mds-data-1'):
from MDSplus import Connection
self._tree = tree
self._shot = shot
self._connection = Connection(server)
super(remoteTree, self).__init__(tree, shot)
def __exit__(self):
self.__del__()
def __del__(self):
try:
self._connection.closeTree(self._tree, self._shot)
finally:
self._connection.__del__()
class remoteTree(_mds.Tree):
def __init__(self, shot='-1', tree='W7X', server='mds-data-1'):
from MDSplus import Connection
self._tree = tree
self._shot = shot
self._connection = Connection(server)
super(remoteTree, self).__init__(tree, shot)
def __exit__(self):
self.__del__()
def __del__(self):
try:
self._connection.closeTree(self._tree, self._shot)
finally:
self._connection.__del__()
def timeout(self,full=False):
def test_timeout(c,expr,to):
with c:
try: # break out of sleep
print(expr)
c.get('write(2,"tic: "//"%s");%s;write(2,"toc: "//"%s")'%(expr,expr,expr),timeout=to)
self.fail('Connection.get("%s") should have timed out.'%expr)
except Exc.MDSplusException as e:
self.assertEqual(e.__class__,Exc.TdiTIMEOUT)
def test_normal(c,expr,**kv):
print(expr)
c.get(expr,**kv)
server,server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',7000+self.index,True)
svr = svr_log = None
try:
svr,svr_log = self._start_mdsip(server ,server_port ,'timeout')
try:
if svr:
self.assertEqual(svr.poll(),None)
c = Connection(server)
test_normal(c,"py('1')") # preload MDSplus on server
test_timeout(c,"wait(3)",1000) # break tdi wait
test_timeout(c,"py('from time import sleep;sleep(3)')",1500) # break python sleep
if full: # timing too unreliable for standard test
test_timeout(c,"for(;1;) ;",100) # break tdi inf.loop
test_timeout(c,"py('while 1: pass')",500) # break python inf.loop
test_normal(c,"1",timeout=1000)
if sys.version_info < (3,7): # TODO: make this work under fc29 (python3.7?)
test_normal(c,"py('1')",timeout=1000) # verify locks are released
self._doTCLTest('stop server %s'%server)
finally:
self._stop_mdsip((svr,server))
finally:
if svr_log: svr_log.close()
def download_shot_numbers(shot_numbers, save_prepath, machine, signals):
max_cores = machine.max_cores
sentinel = -1
fn = partial(
save_shot,
signals=signals,
save_prepath=save_prepath,
machine=machine,
sentinel=sentinel,
)
# can only handle 8 connections at once :(
num_cores = min(mp.cpu_count(), max_cores)
queue = mp.Queue()
# complete_shots = Array('i',zeros(len(shot_numbers)))# = mp.Queue()
# mp.queue can't handle larger queues yet!
assert len(shot_numbers) < 32000
for shot_num in shot_numbers:
queue.put(shot_num)
for i in range(num_cores):
queue.put(sentinel)
connections = [Connection(machine.server) for _ in range(num_cores)]
processes = [
mp.Process(target=fn, args=(queue, connections[i]))
for i in range(num_cores)
]
print("running in parallel on {} processes".format(num_cores))
for p in processes:
p.start()
for p in processes:
p.join()
def plotdata(path='\\ARCHIVESB::DMD10195:CH1',
treename='sandbox',
shot=5,
server=None):
from MDSplus import Connection
from pylab import plot, title, xlabel, ylabel
if server is not None:
Con = Connection(server)
Con.openTree(treename, shot)
name = Con.get('{}:$NAME'.format(path))
data = Con.get('DATA({})'.format(path))
time = Con.get('DIM_OF({})'.format(path))
unit = Con.get('UNITS_OF({})'.format(path))
else:
with Tree(treename, shot) as tree:
Node = tree.getNode(path)
Data = Node.getData()
name = Node.getNode('$NAME').data()
data = Data.data()
time = Data.dim_of().data()
unit = Data.getUnits()
plot(time, data)
xlabel('time (s)')
ylabel(unit)
title(name)
def run(self, jobset, skip_init):
import MDSplus
from MDSplus import Connection
self.error = []
jobs, names = jobset
self.r = {}
self.r['error message'] = ['']
try:
for k, job in enumerate(jobs):
for j in job:
if j.command == 'connection_mode':
if self.connection_str != j.params[0]:
self.connection_str = j.params[0]
server, port, tree = parse_server_string(self.connection_str)
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
res = 'ok'
except:
res = ('connection error' +
traceback.format_exc())
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
res = self._run_job_mdsconnect(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
self.r['error message'] = self.error
return self.r
def connectionThreads(self):
def requests(c,idx):
args = [Float32(i/10+idx) for i in range(10)]
for i in range(10):
self.assertEqual(c.get("[$,$,$,$,$,$,$,$,$,$]",*args).tolist(),args)
c = Connection(self.host)
threads = [Thread(name="C%d"%i,target=requests,args=(c,i)) for i in range(10)]
for thread in threads: thread.start()
for thread in threads: thread.join()
def threadsTcp(self):
server, server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
7100 + self.index, True)
svr = svr_log = None
try:
svr, svr_log = self._start_mdsip(server, server_port, 'tcp')
try:
if svr is not None: time.sleep(1)
def requests(c, idx):
args = [Float32(i / 10 + idx) for i in range(10)]
for i in range(10):
self.assertEqual(
c.get("[$,$,$,$,$,$,$,$,$,$]", *args).tolist(),
args)
c = Connection(server)
""" mdsconnect """
self.assertEqual(c.get('_a=1').tolist(), 1)
self.assertEqual(c.get('_a').tolist(), 1)
self.assertEqual(c.getObject('1:3:1').__class__, Range)
g = GetMany(c)
g.append('a', '1')
g.append('b', '$', 2)
g.append('c', '$+$', 1, 2)
g.execute()
self.assertEqual(g.get('a'), 1)
self.assertEqual(g.get('b'), 2)
self.assertEqual(g.get('c'), 3)
threads = [
Thread(name="C%d" % i, target=requests, args=(c, i))
for i in range(10)
]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
finally:
if svr and svr.poll() is None:
svr.terminate()
svr.wait()
finally:
if svr_log: svr_log.close()
def write(self):
count = 100
def thread(test, name, node, count):
i = -1
max_period = 0
last = start = time.time()
for i in range(count):
data = Float32([i * 10 + 1])
dim = Float32([last])
node.makeSegment(dim[0], dim[0], data, dim)
end = time.time()
max_period = max(end - last, max_period)
last = end
i += 1
test.assertEqual(i, count)
print("%s: rate=%f, max_period=%f" % (name, i /
(end - start), max_period))
server, server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
7020 + self.index, True)
tempdir = tempfile.mkdtemp()
try:
svr, svr_log = self._start_mdsip(server, server_port, 'tcp')
try:
con = Connection(server)
def check(line, *args):
sts = con.get(line, *args)
self.assertTrue(sts & 1, "error %d in '%s'" % (sts, line))
check("setenv('test_path='//$)", tempdir)
for line in (
"TreeOpenNew('test', 1)",
"TreeAddNode('EV1', _, 6)",
"TreeAddNode('EV2', _, 6)",
"TreeWrite()",
"TreeClose()",
):
check(line)
setenv("test_path", "%s::%s" % (server, tempdir))
tree = Tree("test", 1)
_common.TestThread.assertRun(
100,
_common.TestThread('EV1', thread, self, 'EV1',
tree.EV1.copy(), count),
_common.TestThread('EV2', thread, self, 'EV2',
tree.EV2.copy(), count),
)
finally:
if svr_log:
svr_log.close()
self._stop_mdsip((svr, server))
finally:
shutil.rmtree(tempdir, ignore_errors=False, onerror=None)
def _thread_test(self, server):
def requests(self, c, idx):
args = [Int32(i + idx + 10) for i in range(10)]
for _ in range(20):
self.assertEqual(
c.get("[$,$,$,$,$,$,$,$,$,$]", *args).tolist(), args)
connection = Connection(server)
_common.TestThread.assertRun(
100,
*(_common.TestThread("T%d" % idx, requests, self, connection, idx)
for idx in range(5)))
def get_connection(shot, tree='mst'):
"""Get an MDSplus connection object connected to the appropriate
server and having the given tree and shot opened.
"""
svr = get_server_for_shot(shot)
conn, tree_, shot_ = _get_svr_cached(svr)
if conn is None:
conn = Connection(svr)
if tree != tree_ or shot != shot_:
try:
# This throws an exception if there are no open trees.
conn.closeAllTrees()
except:
pass
conn.openTree(tree, shot)
_update_svr_cache(svr, conn, tree, shot)
return conn
def get_data(signal, shot, tree):
cn = CN('mds.ipp.ac.cn')
cn.openTree(tree, shot)
x = cn.get('\\' + signal).copy()
t = cn.get('dim_of(' + '\\' + signal + ')').copy()
cn.closeAllTrees()
t = np.array(t, dtype=np.float64)
x = np.array(x, dtype=np.float64)
return t, x
def data(signal, shot, tree):
import sys
sys.path.append("D:\\Program Files\\MDSplus\\python")
from MDSplus import Connection as CN
cn = CN('mds.ipp.ac.cn')
cn.openTree(tree, shot)
x = cn.get('\\' + signal).copy()
t = cn.get('dim_of(' + '\\' + signal + ')').copy()
cn.closeAllTrees()
t = np.array(t, dtype=np.float64)
x = np.array(x, dtype=np.float64)
return t, x
def threadsLocal(self):
c = Connection('local://gub')
class ConnectionThread(Thread):
def run(self):
for i in range(1000):
self.test.assertEqual(int(c.get('%d' % i)), i)
t1 = ConnectionThread()
t1.test = self
t2 = ConnectionThread()
t2.test = self
t1.start()
t2.start()
t1.join()
t2.join()
def fast_read(sig, shot):
from MDSplus import Connection as CN
conn = CN('mds.ipp.ac.cn')
conn.openTree('east', shot)
x = conn.get('\\' + sig).copy()
t = conn.get('dim_of(' + '\\' + sig + ')').copy()
conn.closeAllTrees()
ind = np.argmin(np.abs(t - 0))
t = t[ind:]
x = x[ind:]
t = np.array(t, dtype=np.float64)
x = np.array(x, dtype=np.float64)
return t, x
def plotdata(path='\\ARCHIVESB::DMD10195:CH1',
treename='sandbox', shot=5, server=None):
from MDSplus import Connection
from pylab import plot, title, xlabel, ylabel
if server is not None:
Con = Connection(server)
Con.openTree(treename, shot)
name = Con.get('{}:$NAME'.format(path))
data = Con.get('DATA({})'.format(path))
time = Con.get('DIM_OF({})'.format(path))
unit = Con.get('UNITS_OF({})'.format(path))
else:
with Tree(treename, shot) as tree:
Node = tree.getNode(path)
Data = Node.getData()
name = Node.getNode('$NAME').data()
data = Data.data()
time = Data.dim_of().data()
unit = Data.getUnits()
plot(time, data)
xlabel('time (s)')
ylabel(unit)
title(name)
def thick(self):
def testnci(thick, local, con, nci):
l = local.S.__getattribute__(nci)
t = thick.S.__getattribute__(nci)
if nci.endswith("_nids"):
l, t = str(l), str(t)
try:
c = str(con.get("getnci(getnci(S,$),'nid_number')", nci))
except TreeNNF:
c = '[]'
else:
c = con.get("getnci(S,$)", nci)
try:
self.assertEqual(t, c)
self.assertEqual(t, l)
except:
print(nci, t, l, c)
raise
server, server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
7000 + self.index, True)
svr, svr_log = self._start_mdsip(server, server_port, 'thick')
try:
con = Connection(server)
self.assertEqual(
con.get("zero([1,1,1,1,1,1,1,1],1)").tolist(),
[[[[[[[[0]]]]]]]])
with Tree(self.tree, -1, "new") as local:
local.addNode(self.treesub, "SUBTREE")
s = local.addNode("S", "SIGNAL")
s.addTag("tagS")
s.record = ADD(Float32(1), Float32(2))
t = local.addNode("T", "TEXT")
t.addNode("TT", "TEXT").addTag("tagTT")
t.record = t.TT
t.TT = "recTT"
local.write()
with Tree(self.treesub, -1, "new") as sub:
sub.addNode("OK")
sub.write()
local.normal()
Tree.setCurrent(self.tree, 7)
setenv("%s_path" % self.tree, "%s::" % server)
print(con.get("getenv($//'_path')", self.tree))
con.get("TreeShr->TreeOpen(ref($),val($),val(1))", self.tree, -1)
thick = Tree(self.tree, -1)
thick.createPulse(1)
thick1 = Tree(self.tree, 1)
self.assertEqual(
getattr(local, self.treesub.upper()).OK.nid,
getattr(thick1, self.treesub.upper()).OK.nid)
local_filename = local.getFileName()
thick_filename = thick.getFileName()
self.assertTrue("::" in thick_filename, thick_filename)
self.assertTrue(local_filename, thick_filename.split("::", 1)[1])
""" TreeTurnOff / TreeTurnOn """
thick.S.on = False
self.assertEqual(local.S.on, False)
thick.S.on = True
self.assertEqual(local.S.on, True)
""" TreeSetCurrentShotId / TreeGetCurrentShotId """
Tree.setCurrent(self.tree, 1)
self.assertEqual(Tree.getCurrent(self.tree), 1)
""" TreeGetRecord / TreeSetRecord """
self.assertEqual(str(local.S.record), "1. + 2.")
self.assertEqual(str(thick.S.record), "1. + 2.")
thick.S.record = ADD(Float32(2), Float32(4))
self.assertEqual(str(local.S.record), "2. + 4.")
self.assertEqual(str(thick.S.record), "2. + 4.")
self.assertEqual(str(local.T.record), str(thick.T.record))
""" GetDefaultNid / SetDefaultNid """
self.assertEqual(thick.getDefault(), thick.top)
thick.setDefault(thick.S)
self.assertEqual(thick.getDefault(), thick.top.S)
thick.setDefault(thick.top)
""" FindNodeWildRemote """
self.assertEqual(str(thick.getNodeWild("T*")),
str(local.getNodeWild("T*")))
""" FindTagWildRemote """
self.assertEqual(thick.findTags("*"), local.findTags("*"))
""" nci """
thick.S.write_once = True
self.assertEqual(thick.S.write_once, True)
for nci in (
'on',
'depth',
'usage_str',
'dtype',
'length',
'rlength',
'fullpath',
'minpath',
'member_nids',
'children_nids',
'rfa',
'write_once',
):
testnci(thick, local, con, nci)
""" new stuff """
self.assertEqual(local.getFileName(),
con.get("treefilename($,-1)", self.tree))
finally:
if svr_log:
svr_log.close()
self._stop_mdsip((svr, server))
def __init__(self, shot='-1', tree='W7X', server='mds-data-1'):
from MDSplus import Connection
self._tree = tree
self._shot = shot
self._connection = Connection(server)
super(remoteTree, self).__init__(tree, shot)
def get(self, expr, *args, **kwargs):
print 'expression' + expr
return Connection.get(self, expr, *args, **kwargs)
def test():
from time import sleep
hosts = '%s/mdsip.hosts' % self.root
def testDispatchCommand(mdsip, command, stdout=None, stderr=None):
self.assertEqual(
tcl(
'dispatch/command/nowait/server=%s %s' %
(mdsip, command), 1, 1, 1), (None, None))
def setup_mdsip(server_env, port_env, default_port, fix0):
host = getenv(server_env, '')
if len(host) > 0:
return host, 0
port = int(getenv(port_env, default_port))
if port == 0:
if fix0: port = default_port
else: return None, 0
return 'localhost:%d' % (port, ), port
def start_mdsip(server, port, logname, env=None):
if port > 0:
from subprocess import Popen, STDOUT
logfile = '%s_%d.log' % (logname, self.index)
log = open(logfile, 'w')
try:
params = ['mdsip', '-s', '-p', str(port), '-h', hosts]
print(' '.join(params + ['&>', logfile]))
mdsip = Popen(params,
env=env,
stdout=log,
stderr=STDOUT)
except:
log.close()
raise
return mdsip, log
if server:
for envpair in self.envx.items():
testDispatchCommand(server, 'env %s=%s' % envpair)
return None, None
monitor, monitor_port = setup_mdsip('ACTION_MONITOR',
'MONITOR_PORT',
8700 + self.index, False)
monitor_opt = "/monitor=%s" % monitor if monitor_port > 0 else ""
server, server_port = setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
8800 + self.index, True)
shot = self.shot + 1
Tree('pytree', -1, 'ReadOnly').createPulse(shot)
show_server = "Checking server: %s\n[^,]+, [^,]+, logging enabled, Inactive\n" % server
pytree = Tree('pytree', shot)
pytree.TESTDEVICE.ACTIONSERVER.no_write_shot = False
pytree.TESTDEVICE.ACTIONSERVER.record = server
""" using dispatcher """
mon, mon_log, svr, svr_log = (None, None, None, None)
try:
mon, mon_log = start_mdsip(monitor, monitor_port, 'monitor')
svr, svr_log = start_mdsip(server, server_port, 'server',
self.env)
try:
sleep(3)
if mon: self.assertEqual(mon.poll(), None)
if svr: self.assertEqual(svr.poll(), None)
""" mdsconnect """
c = Connection(server)
self.assertEqual(c.get('1').tolist(), 1)
self.assertEqual(c.getObject('1:3:1').__class__, Range)
if not sys.platform.startswith(
'win'): # Windows does not support timeout yet
try: # currently the connection needs to be closed after a timeout
Connection(server).get("wait(1)", timeout=100)
self.fail(
"Connection.get(wait(1)) should have timed out."
)
except Exc.MDSplusException as e:
self.assertEqual(e.__class__, Exc.TdiTIMEOUT)
g = GetMany(c)
g.append('a', '1')
g.append('b', '$', 2)
g.append('c', '$+$', 1, 2)
g.execute()
self.assertEqual(g.get('a'), 1)
self.assertEqual(g.get('b'), 2)
self.assertEqual(g.get('c'), 3)
""" tcl dispatch """
self._doTCLTest('show server %s' % server,
out=show_server,
re=True)
testDispatchCommand(server, 'set verify')
testDispatchCommand(server, 'type test')
self._doTCLTest('set tree pytree/shot=%d' % shot)
self._doTCLTest('dispatch/build%s' % monitor_opt)
self._doTCLTest('dispatch/phase%s INIT' % monitor_opt)
sleep(1)
self._doTCLTest('show server %s' % server,
out=show_server,
re=True)
self._doTCLTest('dispatch/phase%s PULSE' % monitor_opt)
sleep(1)
self._doTCLTest('show server %s' % server,
out=show_server,
re=True)
self._doTCLTest('dispatch/phase%s STORE' % monitor_opt)
sleep(1)
self._doTCLTest('show server %s' % server,
out=show_server,
re=True)
""" tcl exceptions """
self._doExceptionTest(
'dispatch/command/server=%s ' % server,
Exc.MdsdclIVVERB)
""" tcl check if still alive """
if mon: self.assertEqual(mon.poll(), None)
if svr: self.assertEqual(svr.poll(), None)
finally:
try:
self._doTCLTest(
'dispatch/command/wait/server=%s close/all' %
server)
finally:
if svr and svr.poll() is None:
svr.terminate()
svr.wait()
if mon and mon.poll() is None:
mon.terminate()
mon.wait()
finally:
if svr_log: svr_log.close()
if mon_log: mon_log.close()
self._doTCLTest('close/all')
pytree = Tree('pytree', shot, 'ReadOnly')
self.assertTrue(pytree.TESTDEVICE.INIT1_DONE.record <=
pytree.TESTDEVICE.INIT2_DONE.record)
start = time()
d = c.Data.execute('random($)', samples).data()
end = time()
print(
"""
Speed test for connection to %s
Using dill for pickling: %s
Floating point samples retrieved: %d
MBytes received: %g
Transaction time in seconds: %g
Transfer speed in MB/s: %g
""" %
(host, usingDill, samples, d.nbytes * 1E-6, end - start, d.nbytes * 1E-6 /
(end - start)))
c.connection.close()
if mdsip is not None:
from MDSplus import Connection
c = Connection(mdsip)
start = time()
d = c.get('random($)', samples).data()
end = time()
print("""
Speed test for mdsip connection to %s
Floating point samples retrieved: %d
MBytes received: %g
Transaction time in seconds: %g
Transfer speed in MB/s: %g
""" % (mdsip, samples, d.nbytes * 1E-6, end - start, d.nbytes * 1E-6 /
(end - start)))
class JobRunner(object):
def __init__(self):
self.use_mdsconnect = False
self.connection_str = ''
self.connection = None
self.g = {}
self._shot = -1
self.gjob = None # global tdi (executed when shot number changed)
self._tree = ''
self._defnode = ''
def __del__(self):
if self.connection is not None:
del self.connection
def run(self, jobset, skip_init):
# def _evaluate_sig(res, sig_names, dim_names):
# for name in dim_names:
# try:
# src, dim = res[name][0:3].split(',')
# res[name] = res[src].dim_of(long(dim)).data()
# except:
# pass
# for name in sig_names:
# try:
# res[name] = res[name].data()
# except:
# pass
# return res
self.error = []
jobs, names = jobset
self.r = {'error message': []}
sig_names = []
dim_names = []
try:
for k, job in enumerate(jobs):
for j in job:
# print j
if j.command == 'connection_mode':
# print 'connection_mode param', self.connection_str, j.params, self.connection
# if self.connection is not None:
# del self.connection
# self.connection = None
if self.connection_str != j.params[0]:
# if True:
server, port, tree = parse_server_string(
j.params[0])
self.use_mdsconnect = (False if server.upper()
== 'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
self.connection = None
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = j.params[0]
res = 'ok'
except:
self.r['error message'] = [
'connection error' +
traceback.format_exc()
]
self.r[names[k]] = None
return self.r
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
self._connection_flag = True
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
# res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
#ttt = time.time()
res = self._run_job_mdsconnect(j)
#print time.time() - ttt, j
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
self._connection_flag = False
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
# self.r = _evaluate_sig(self.r, sig_names, dim_names)
self.r['error message'] = self.error
return self.r
def set_globaljob(self, job):
self.gjob = job
def terminate(self):
if self.connection is not None:
del self.connection
self.connection = None
def _run_script_txt(self, job):
expr = job.params[0]
try:
code = compile(expr, '<string>', 'exec')
g = {}
l = {}
exec code in self.g, self.r
return 'ok'
except:
self.error = ['Scrip Error', expr, sys.exc_info()[0]]
return None
# def _run_job_mdsconnect(self, job, sig_names,dim_names, name):
def _run_job_mdsconnect(self, job):
com = job.command
if com == 'novalue': return ''
if debug_runner: print(job)
#print threading.current_thread().name, com, job.params
if com == 'open':
tree = job.params[0]
shot = job.params[1]
if self._tree != tree or self._shot != shot:
try:
#print tree,
#print long(shot)
if tree != '':
self.connection.openTree(tree, long(shot))
except:
self.error = ['run error', traceback.format_exc()]
return None
try:
t = tree.split(',')[0].strip()
node = '\\' + t + '::TOP'
if node != self._defnode:
self.connection.setDefault(node)
self._defnode = node
except:
pass
try:
if shot != self._shot:
expr = 'reset_private();reset_public();1'
r = self.connection.get(expr).data()
if self._connection_flag:
if self.gjob is not None:
expr = self.gjob.params[0]
#print 'performing global tdi', expr
r = self.connection.get(expr).data()
self._connection_flag = False
self._shot = shot
self._tree = tree
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
if node != self._defnode:
self.connection.setDefault(node)
self._defnode = node
return 'ok'
except:
print(node)
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r = self.connection.get(expr).data()
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
elif com == 'valuesig':
try:
expr = job.params[0]
r = self.connection.get('_piscopevar=execute($)', expr).data()
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
# elif com == 'dim_of':# this is not used anymore
# expr = job.params[0]
# dim_names.append(name)
# return expr
elif com == 'script_txt':
return self._run_script_txt(job)
# def _run_job(self, job, sig_names, dim_names, name):
def _run_job(self, job):
import MDSplus
from MDSplus import Connection
com = job.command
if com == 'novalue': return ''
if com == 'open':
tree = job.params[0]
shot = job.params[1]
try:
if tree != '':
self.t = MDSplus.Tree(tree, long(shot))
if shot != self._shot:
expr = 'reset_private();reset_public();1'
# r =MDSplus.Data.compile(expr).evaluate().data()
r = MDSplus.Data.execute(expr).data()
if self._connection_flag:
if self.gjob is not None:
expr = self.gjob.params[0]
r = MDSplus.Data.execute(expr).data()
self._connection_flag = False
self._shot = shot
return 'ok'
except:
# print traceback.format_exc()
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r = MDSplus.Data.execute(expr).data()
# r =MDSplus.Data.execute(expr).data()
# sig_names.append(name)
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
elif com == 'valuesig':
try:
expr = job.params[0]
r = MDSplus.Data.execute('_piscopevar=execute($)', expr).data()
# r =MDSplus.Data.execute(expr).data()
# sig_names.append(name)
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
# elif com == 'dim_of': # this is not used anymore
# expr = job.params[0] ### expr should be y, 0 (= dim_of(y, 0))
# dim_names.append(name)
# return expr
elif com == 'script_txt':
return self._run_script_txt(job)
def run(self, jobset, skip_init):
# def _evaluate_sig(res, sig_names, dim_names):
# for name in dim_names:
# try:
# src, dim = res[name][0:3].split(',')
# res[name] = res[src].dim_of(long(dim)).data()
# except:
# pass
# for name in sig_names:
# try:
# res[name] = res[name].data()
# except:
# pass
# return res
self.error = []
jobs, names = jobset
self.r = {'error message': []}
sig_names = []
dim_names = []
try:
for k, job in enumerate(jobs):
for j in job:
# print j
if j.command == 'connection_mode':
# print 'connection_mode param', self.connection_str, j.params, self.connection
# if self.connection is not None:
# del self.connection
# self.connection = None
if self.connection_str != j.params[0]:
# if True:
server, port, tree = parse_server_string(
j.params[0])
self.use_mdsconnect = (False if server.upper()
== 'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
self.connection = None
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = j.params[0]
res = 'ok'
except:
self.r['error message'] = [
'connection error' +
traceback.format_exc()
]
self.r[names[k]] = None
return self.r
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
self._connection_flag = True
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
# res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
#ttt = time.time()
res = self._run_job_mdsconnect(j)
#print time.time() - ttt, j
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
self._connection_flag = False
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
# self.r = _evaluate_sig(self.r, sig_names, dim_names)
self.r['error message'] = self.error
return self.r
def run(self, jobset, skip_init):
# def _evaluate_sig(res, sig_names, dim_names):
# for name in dim_names:
# try:
# src, dim = res[name][0:3].split(',')
# res[name] = res[src].dim_of(long(dim)).data()
# except:
# pass
# for name in sig_names:
# try:
# res[name] = res[name].data()
# except:
# pass
# return res
self.error = []
jobs, names = jobset
self.r = {'error message': []}
sig_names = []
dim_names = []
try:
for k, job in enumerate(jobs):
for j in job:
# print j
if j.command == 'connection_mode':
# print 'connection_mode param', self.connection_str, j.params, self.connection
# if self.connection is not None:
# del self.connection
# self.connection = None
if self.connection_str != j.params[0]:
# if True:
server, port, tree = parse_server_string(j.params[0])
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
self.connection = None
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = j.params[0]
res = 'ok'
except:
self.r['error message'] = ['connection error' +
traceback.format_exc()]
self.r[names[k]] = None
return self.r
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
self._connection_flag = True
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
# res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
#ttt = time.time()
res = self._run_job_mdsconnect(j)
#print time.time() - ttt, j
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
self._connection_flag = False
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
# self.r = _evaluate_sig(self.r, sig_names, dim_names)
self.r['error message'] = self.error
return self.r
class JobRunner(object):
def __init__(self):
self.use_mdsconnect = False
self.connection_str = ''
self.connection = None
self.g = {}
self._shot = -1
def run(self, jobset, skip_init):
import MDSplus
from MDSplus import Connection
self.error = []
jobs, names = jobset
self.r = {}
self.r['error message'] = ['']
try:
for k, job in enumerate(jobs):
for j in job:
if j.command == 'connection_mode':
if self.connection_str != j.params[0]:
self.connection_str = j.params[0]
server, port, tree = parse_server_string(self.connection_str)
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
res = 'ok'
except:
res = ('connection error' +
traceback.format_exc())
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
res = self._run_job_mdsconnect(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error
self.r[names[k]] = res
return self.r
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
self.r['error message'] = self.error
return self.r
def _run_script_txt(self, job):
expr = job.params[0]
try:
code = compile(expr, '<string>', 'exec')
g = {}
l = {}
exec code in self.g, self.r
return 'ok'
except:
self.error = ['Scrip Error', expr, sys.exc_info()[0]]
return None
def _run_job_mdsconnect(self, job):
com = job.command
if com == 'open':
tree = job.params[0]
shot = job.params[1]
try:
self.connection.openTree(tree, long(shot))
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
self._shot = shot
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
self.connection.setDefault(node)
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r =self.connection.get(expr).data()
return r
except:
self.error = ['run error', expr,traceback.format_exc()]
return None
elif com == 'script_txt':
return self._run_script_txt(job)
def _run_job(self, job):
import MDSplus
from MDSplus import Connection
com = job.command
if com == 'open':
tree = job.params[0]
shot = job.params[1]
try:
self.t = MDSplus.Tree(tree, long(shot))
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
self._shot = shot
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r =MDSplus.Data.compile(expr).evaluate().data()
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
elif com == 'script_txt':
return self._run_script_txt(job)
class ForkingTCPRequestHandler(SocketServer.StreamRequestHandler):
#
def __init__(self, *args, **kargs):
name = '/tmp/mdsplus_gateway_'+str(os.getpid()) +'.log'
self.use_mdsconnect = False
self.connection_str = ''
self.connection = None
if write_handler_log:
self.fid = open(name, 'w')
else:
self.fid = None
SocketServer.StreamRequestHandler.__init__(self, *args, **kargs)
def write_log(self, txt):
if self.fid is not None:
self.fid.write(txt + '\n')
def handle(self):
try:
while True:
self.loop_handler()
except:
pass
def loop_handler(self):
message = self.rfile.readline().strip()
if self.fid is not None:
self.fid.write('handling input \n' + message + '\n')
asmessage = binascii.a2b_hex(message)
# logging.basicConfig(level = logging.DEBUG)
try:
data = pickle.loads(asmessage)
except ValueError, EOFError:
if self.fid is not None:
self.fid.write('picke error \n')
self.fid.flush()
# logging.exception('picke load error', len(message))
# response = None
# return
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write('handling request \n' + str(data) + '\n')
self.fid.flush()
r = {}
for name, commands in data:
for command in commands:
com = command[0]
param = command[1:]
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write(com + ':' + param + '\n')
self.fid.flush()
if com == 's':
server, port, tree = parse_server_string(param)
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
try:
if self.connection_str != param:
del self.connection
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = param
r[name] = 'ok'
except:
r[name] = 'connection error'
self.error = ['connection error', self.connection_str]
else:
if self.connection is not None:
del self.connection
self.connection = None
self.connection_str = ''
r[name] = 'ok'
else:
self.error = []
if self.use_mdsconnect:
r[name] = self._handle_mdsconnect(com, param)
else:
r[name] = self._handle(com, param)
if len(self.error) != 0:
if self.fid is not None:
self.fid.write(str(self.error))
self.fid.flush()
if self.fid is not None:
self.fid.write('return variables \n' + str(r.keys()) + '\n')
self.fid.flush()
sr=pickle.dumps(r)
response = binascii.b2a_hex(sr)
if self.fid is not None:
self.fid.write('sending data (length) \n' +
str(len(response)) + '\n')
self.fid.flush()
self.request.sendall(response+'\n')
if self.fid is not None:
self.fid.flush()
class ForkingTCPRequestHandler(socketserver.StreamRequestHandler):
#
def __init__(self, *args, **kargs):
name = '/tmp/mdsplus_gateway_' + str(os.getpid()) + '.log'
self.use_mdsconnect = False
self.connection_str = ''
self.connection = None
if write_handler_log:
self.fid = open(name, 'w')
else:
self.fid = None
socketserver.StreamRequestHandler.__init__(self, *args, **kargs)
def write_log(self, txt):
if self.fid is not None:
self.fid.write(txt + '\n')
def handle(self):
try:
while True:
self.loop_handler()
except:
pass
def loop_handler(self):
message = self.rfile.readline().strip()
if self.fid is not None:
self.fid.write('handling input \n' + message + '\n')
asmessage = binascii.a2b_hex(message)
# logging.basicConfig(level = logging.DEBUG)
try:
data = pickle.loads(asmessage)
except ValueError as EOFError:
if self.fid is not None:
self.fid.write('picke error \n')
self.fid.flush()
# logging.exception('picke load error', len(message))
# response = None
# return
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write('handling request \n' + str(data) + '\n')
self.fid.flush()
r = {}
for name, commands in data:
for command in commands:
com = command[0]
param = command[1:]
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write(com + ':' + param + '\n')
self.fid.flush()
if com == 's':
server, port, tree = parse_server_string(param)
self.use_mdsconnect = (False if server.upper() == 'DIRECT'
else True)
if self.use_mdsconnect:
try:
if self.connection_str != param:
del self.connection
if port != '':
server = server + ':' + port
self.connection = Connection(server)
self.connection_str = param
r[name] = 'ok'
except:
r[name] = 'connection error'
self.error = [
'connection error', self.connection_str
]
else:
if self.connection is not None:
del self.connection
self.connection = None
self.connection_str = ''
r[name] = 'ok'
else:
self.error = []
if self.use_mdsconnect:
r[name] = self._handle_mdsconnect(com, param)
else:
r[name] = self._handle(com, param)
if len(self.error) != 0:
if self.fid is not None:
self.fid.write(str(self.error))
self.fid.flush()
if self.fid is not None:
self.fid.write('return variables \n' + str(list(r.keys())) + '\n')
self.fid.flush()
sr = pickle.dumps(r)
response = binascii.b2a_hex(sr)
if self.fid is not None:
self.fid.write('sending data (length) \n' + str(len(response)) +
'\n')
self.fid.flush()
self.request.sendall(response + '\n')
if self.fid is not None:
self.fid.flush()
def _handle_mdsconnect(self, com, param):
response = ''
self.write_log(str(com) + ':' + str(param))
if com == 'c': # connection request
arr = param.split(',')
tree = ','.join(arr[:-1])
shot = arr[-1]
try:
if tree != '':
self.write_log('opening tree :' + str(tree) + ':' +
str(shot))
self.connection.openTree(tree, int(shot))
response = 'ok'
except Exception:
self.error = ['run error', traceback.format_exc()]
response = None
elif com == 'd':
node = param
self.write_log('setting def node ' + str(node))
try:
if node.strip() != '':
self.connection.setDefault(node)
response = 'ok'
except Exception:
self.error = ['run error', traceback.format_exc()]
response = None
elif com == 'v': # mdsvalue
self.write_log('mdsvalue ' + str(param))
try:
response = self.connection.get(param).data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
elif com == 'u': # mdsvalue
self.write_log('mdsvalue ' + str(param))
try:
response = self.connection.get('_piscopevar=execute($)',
param).data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
elif com == 'w': # dim_of (this is not used anymore)
self.write_log('dim_of ' + str(param))
expr = param[1:]
dim = int(param[0])
try:
# response =MDSplus.Data.compile(param).evaluate().data()
response = self.connection.get(expr).dim_of(dim).data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
# self.write_log(response.__repr__())
return response
def _handle(self, com, param):
response = ''
self.write_log(str(com) + ' ' + str(param))
if com == 'c': # connection request
arr = param.split(',')
tree = ','.join(arr[:-1])
shot = arr[-1]
try:
if tree != '':
self.write_log('opening tree ' + str(tree) + ' ' +
str(shot))
self.t = MDSplus.Tree(tree, int(shot))
self.write_log('opening tree ' + str(self.t))
response = 'ok'
except Exception:
self.error = ['run error', traceback.format_exc()]
response = None
elif com == 'd':
node = param
self.write_log('setting def node ' + str(node))
try:
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
response = 'ok'
except Exception:
self.error = ['run error', traceback.format_exc()]
response = None
elif com == 'f': # connection request
a = param.split(',')
tree = a[0]
shot = a[1]
node = a[2]
expr = ','.join(a[3:])
try:
self.t = MDSplus.Tree(tree, int(shot))
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
response = MDSplus.Data.compile(expr).evaluate().data()
except Exception:
self.error = ['run error', expr, traceback.format_exc()]
response = None
elif com == 'v': # mdsvalue
self.write_log('mdsvalue ' + str(param))
try:
response = MDSplus.Data.compile(param).evaluate().data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
elif com == 'u': # mdsvalue
self.write_log('mdsvalue ' + str(param))
try:
response = MDSplus.Data.execute('_piscopevar=execute($)',
param).data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
elif com == 'w': # dim_of (this is not used anymore)
self.write_log('dim_of ' + str(param))
expr = param[1:]
dim = int(param[0])
try:
# response =MDSplus.Data.compile(param).evaluate().data()
response = MDSplus.Data.execute(expr).dim_of(dim).data()
except Exception:
self.error = ['run error', param, traceback.format_exc()]
response = None
return response
def run(self, jobset, skip_init):
import MDSplus
from MDSplus import Connection
self.error = []
jobs, names = jobset
self.r = {'error message': []}
sig_names = []
dim_names = []
try:
for k, job in enumerate(jobs):
for j in job:
if j.command == 'connection_mode':
# print 'connection_mode param', self.connection_str, j.params, self.connection
# if self.connection is not None:
# del self.connection
# self.connection = None
if self.connection_str != j.params[0]:
# if True:
server, port, tree = parse_server_string(j.params[0])
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
self.connection = None
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = j.params[0]
res = 'ok'
except:
self.r['error message'] = ['connection error' +
traceback.format_exc()]
self.r[names[k]] = None
return self.r
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
self._connection_flag = True
else:
res = 'ok'
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
# res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
res = self._run_job_mdsconnect(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
self._connection_flag = False
# return _evaluate_sig(self.r, sig_names, dim_names)
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
# self.r = _evaluate_sig(self.r, sig_names, dim_names)
self.r['error message'] = self.error
return self.r
def loop_handler(self):
message = self.rfile.readline().strip()
if self.fid is not None:
self.fid.write('handling input \n' + message + '\n')
asmessage = binascii.a2b_hex(message)
# logging.basicConfig(level = logging.DEBUG)
try:
data = pickle.loads(asmessage)
except ValueError as EOFError:
if self.fid is not None:
self.fid.write('picke error \n')
self.fid.flush()
# logging.exception('picke load error', len(message))
# response = None
# return
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write('handling request \n' + str(data) + '\n')
self.fid.flush()
r = {}
for name, commands in data:
for command in commands:
com = command[0]
param = command[1:]
#cur_thread = threading.current_thread()
if self.fid is not None:
self.fid.write(com + ':' + param + '\n')
self.fid.flush()
if com == 's':
server, port, tree = parse_server_string(param)
self.use_mdsconnect = (False if server.upper() == 'DIRECT'
else True)
if self.use_mdsconnect:
try:
if self.connection_str != param:
del self.connection
if port != '':
server = server + ':' + port
self.connection = Connection(server)
self.connection_str = param
r[name] = 'ok'
except:
r[name] = 'connection error'
self.error = [
'connection error', self.connection_str
]
else:
if self.connection is not None:
del self.connection
self.connection = None
self.connection_str = ''
r[name] = 'ok'
else:
self.error = []
if self.use_mdsconnect:
r[name] = self._handle_mdsconnect(com, param)
else:
r[name] = self._handle(com, param)
if len(self.error) != 0:
if self.fid is not None:
self.fid.write(str(self.error))
self.fid.flush()
if self.fid is not None:
self.fid.write('return variables \n' + str(list(r.keys())) + '\n')
self.fid.flush()
sr = pickle.dumps(r)
response = binascii.b2a_hex(sr)
if self.fid is not None:
self.fid.write('sending data (length) \n' + str(len(response)) +
'\n')
self.fid.flush()
self.request.sendall(response + '\n')
if self.fid is not None:
self.fid.flush()
def get_input():
shots = []
signals = []
trees = []
labels = []
processes = []
parameters = []
for i in range(1, 6):
shot = names['shot' + str(i)].get()
if len(shot) > 0:
shot = int(shot)
shots.append(shot)
else:
if i == 1:
from MDSplus import Connection as CN
cn = CN('mds.ipp.ac.cn')
shot = cn.get("current_shot('east')")
shot = int(shot)
shots.append(shot)
for i in range(1, 8):
signal = names['signal' + str(i)].get()
tree = names['tree' + str(i)].get()
label = names['label' + str(i)].get()
process = names['process' + str(i)].get()
parameter = names['parameter' + str(i)].get()
if len(signal) > 0:
signals.append(signal)
if len(tree) == 0:
trees.append('east_1')
else:
trees.append(tree)
if len(label) == 0:
labels.append(signal)
else:
labels.append(label)
if len(process) == 0:
processes.append('None')
parameters.append('None')
else:
processes.append(process)
if len(parameter) == 0:
parameters.append('None')
else:
parameter_list = parameter.split(",")
parameter = [
float(parameter_list[i])
for i in range(len(parameter_list))
]
parameters.append(parameter)
begin_time = begin.get()
end_time = end.get()
if len(begin_time) == 0:
begin_time = 0
if len(end_time) == 0:
end_time = 10
begin_time = float(begin_time)
end_time = float(end_time)
low_frequency = low_filter.get()
if len(low_frequency) == 0:
low_frequency = 0
low_frequency = int(low_frequency)
up_frequency = up_filter.get()
if len(up_frequency) == 0:
up_frequency = 0
up_frequency = int(up_frequency)
return shots, signals, trees, begin_time, end_time, low_frequency, up_frequency, labels, processes, parameters
class EventListener(threading.Thread):
def __init__(self, *args, **kargs):
super(EventListener, self).__init__(*args, **kargs)
self.queue = mp.Queue() # queue to receive message
self.task_queue = mp.JoinableQueue()
self.listener_proc = EventListenerProc(self.task_queue, self.queue)
self.listener_proc.start()
def run(self, *args, **kargs):
while True:
event_name = self.queue.get(True)
if event_name == 'stop':
#globals()['listener_thread'] = None
return
mds_event_listener_lock.acquire()
check = False
# do nothing
mds_event_listener_lock.release()
if __name__ == '__main__':
server = 'ssh://[email protected]' # this makes a dead-lokc
# server = 'alcdata.psfc.mit.edu' # this works
c = Connection(server)
listener_thread = EventListener()
listener_thread.task_queue.put(('exit', ''), False)
listener_thread.queue.put('stop')
print('good bye')
def get_connection(self):
return Connection(self.server)
def get(self, expr, *args, **kwargs):
print 'expression'+expr
return Connection.get(self, expr, *args, **kwargs)
def get_input():
signals1 = []
trees1 = []
labels1 = []
zooms1 = []
signals2 = []
trees2 = []
labels2 = []
zooms2 = []
signals3 = []
trees3 = []
labels3 = []
zooms3 = []
units = []
shot = names['shot1'].get()
if len(shot) > 0:
shot = int(shot)
else:
from MDSplus import Connection as CN
cn = CN('mds.ipp.ac.cn')
shot = cn.get("current_shot('east')")
shot = int(shot)
for i in range(1, 8):
signal1 = names['signal1' + str(i)].get()
tree1 = names['tree1' + str(i)].get()
label1 = names['label1' + str(i)].get()
zoom1 = names['zoom1' + str(i)].get()
signal2 = names['signal2' + str(i)].get()
tree2 = names['tree2' + str(i)].get()
label2 = names['label2' + str(i)].get()
zoom2 = names['zoom2' + str(i)].get()
signal3 = names['signal3' + str(i)].get()
tree3 = names['tree3' + str(i)].get()
label3 = names['label3' + str(i)].get()
zoom3 = names['zoom3' + str(i)].get()
unit = names['unit' + str(i)].get()
if len(signal1) > 0:
signals1.append(signal1)
if len(tree1) == 0:
trees1.append('east_1')
else:
trees1.append(tree1)
if len(label1) == 0:
labels1.append(signal1)
else:
labels1.append(label1)
if len(zoom1) == 0:
zooms1.append(1)
else:
zooms1.append(float(zoom1))
if len(signal2) > 0:
signals2.append(signal2)
if len(tree2) == 0:
trees2.append('east_1')
else:
trees2.append(tree2)
if len(label2) == 0:
labels2.append(signal2)
else:
labels2.append(label2)
if len(zoom2) == 0:
zooms2.append(1)
else:
zooms2.append(float(zoom2))
else:
signals2.append('0')
trees2.append('0')
labels2.append('0')
zooms2.append(0)
if len(signal3) > 0:
signals3.append(signal3)
if len(tree3) == 0:
trees3.append('east_1')
else:
trees3.append(tree3)
if len(label3) == 0:
labels3.append(signal3)
else:
labels3.append(label3)
if len(zoom3) == 0:
zooms3.append(1)
else:
zooms3.append(float(zoom3))
else:
signals3.append('0')
trees3.append('0')
labels3.append('0')
zooms3.append(0)
if len(unit) > 0:
units.append(unit)
else:
units.append('0')
begin_time = begin.get()
end_time = end.get()
if len(begin_time) == 0:
begin_time = 0
if len(end_time) == 0:
end_time = 10
begin_time = float(begin_time)
end_time = float(end_time)
low_frequency = low_filter.get()
if len(low_frequency) == 0:
low_frequency = 0
low_frequency = int(low_frequency)
up_frequency = up_filter.get()
if len(up_frequency) == 0:
up_frequency = 0
up_frequency = int(up_frequency)
return shot, signals1, trees1, labels1, zooms1, signals2, trees2, labels2, zooms2, signals3, trees3, labels3, zooms3, units, begin_time, end_time, low_frequency, up_frequency
class JobRunner(object):
def __init__(self):
self.use_mdsconnect = False
self.connection_str = ''
self.connection = None
self.g = {}
self._shot = -1
self.gjob = None # global tdi (executed when shot number changed)
self._tree = ''
self._defnode = ''
def __del__(self):
if self.connection is not None:
del self.connection
def run(self, jobset, skip_init):
# def _evaluate_sig(res, sig_names, dim_names):
# for name in dim_names:
# try:
# src, dim = res[name][0:3].split(',')
# res[name] = res[src].dim_of(long(dim)).data()
# except:
# pass
# for name in sig_names:
# try:
# res[name] = res[name].data()
# except:
# pass
# return res
self.error = []
jobs, names = jobset
self.r = {'error message': []}
sig_names = []
dim_names = []
try:
for k, job in enumerate(jobs):
for j in job:
# print j
if j.command == 'connection_mode':
# print 'connection_mode param', self.connection_str, j.params, self.connection
# if self.connection is not None:
# del self.connection
# self.connection = None
if self.connection_str != j.params[0]:
# if True:
server, port, tree = parse_server_string(j.params[0])
self.use_mdsconnect = (False if server.upper() ==
'DIRECT' else True)
if self.use_mdsconnect:
if self.connection is not None:
del self.connection
self.connection = None
try:
if port != '': server = server + ':' + port
self.connection = Connection(server)
self.connection_str = j.params[0]
res = 'ok'
except:
self.r['error message'] = ['connection error' +
traceback.format_exc()]
self.r[names[k]] = None
return self.r
else:
if self.connection is not None:
del self.connection
self.connection = None
res = 'ok'
else:
res = 'ok'
self._connection_flag = True
else:
if j.command == 'init':
if skip_init:
continue
else:
j.command = 'value'
if self.use_mdsconnect:
# res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
#ttt = time.time()
res = self._run_job_mdsconnect(j)
#print time.time() - ttt, j
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
else:
res = self._run_job(j)
if len(self.error) != 0:
self.r['error message'] = self.error[:]
self.r[names[k]] = res
return self.r
# return _evaluate_sig(self.r, sig_names, dim_names)
self._connection_flag = False
self.r[names[k]] = res
except:
self.error = ['run error', traceback.format_exc()]
# self.r = _evaluate_sig(self.r, sig_names, dim_names)
self.r['error message'] = self.error
return self.r
def set_globaljob(self, job):
self.gjob = job
def terminate(self):
if self.connection is not None:
del self.connection
self.connection = None
def _run_script_txt(self, job):
expr = job.params[0]
try:
code = compile(expr, '<string>', 'exec')
g = {}
l = {}
exec code in self.g, self.r
return 'ok'
except:
self.error = ['Scrip Error', expr, sys.exc_info()[0]]
return None
# def _run_job_mdsconnect(self, job, sig_names,dim_names, name):
def _run_job_mdsconnect(self, job):
com = job.command
if com == 'novalue': return ''
if debug_runner: print(job)
#print threading.current_thread().name, com, job.params
if com == 'open':
tree = job.params[0]
shot = job.params[1]
if self._tree != tree or self._shot != shot:
try:
#print tree,
#print long(shot)
if tree != '':
self.connection.openTree(tree, long(shot))
except:
self.error = ['run error', traceback.format_exc()]
return None
try:
t = tree.split(',')[0].strip()
node = '\\'+ t +'::TOP'
if node != self._defnode:
self.connection.setDefault(node)
self._defnode = node
except:
pass
try:
if shot != self._shot:
expr = 'reset_private();reset_public();1'
r =self.connection.get(expr).data()
if self._connection_flag:
if self.gjob is not None:
expr = self.gjob.params[0]
#print 'performing global tdi', expr
r =self.connection.get(expr).data()
self._connection_flag = False
self._shot = shot
self._tree = tree
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
if node != self._defnode:
self.connection.setDefault(node)
self._defnode = node
return 'ok'
except:
print(node)
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r =self.connection.get(expr).data()
return r
except:
self.error = ['run error', expr,traceback.format_exc()]
return None
elif com == 'valuesig':
try:
expr = job.params[0]
r =self.connection.get('_piscopevar=execute($)', expr).data()
return r
except:
self.error = ['run error', expr,traceback.format_exc()]
return None
# elif com == 'dim_of':# this is not used anymore
# expr = job.params[0]
# dim_names.append(name)
# return expr
elif com == 'script_txt':
return self._run_script_txt(job)
# def _run_job(self, job, sig_names, dim_names, name):
def _run_job(self, job):
import MDSplus
from MDSplus import Connection
com = job.command
if com == 'novalue': return ''
if com == 'open':
tree = job.params[0]
shot = job.params[1]
try:
if tree != '':
self.t = MDSplus.Tree(tree, long(shot))
if shot != self._shot:
expr = 'reset_private();reset_public();1'
# r =MDSplus.Data.compile(expr).evaluate().data()
r =MDSplus.Data.execute(expr).data()
if self._connection_flag:
if self.gjob is not None:
expr = self.gjob.params[0]
r =MDSplus.Data.execute(expr).data()
self._connection_flag = False
self._shot = shot
return 'ok'
except:
# print traceback.format_exc()
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'defnode':
node = job.params[0]
try:
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
return 'ok'
except:
self.error = ['run error', traceback.format_exc()]
return None
elif com == 'value':
try:
expr = job.params[0]
r =MDSplus.Data.execute(expr).data()
# r =MDSplus.Data.execute(expr).data()
# sig_names.append(name)
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
elif com == 'valuesig':
try:
expr = job.params[0]
r =MDSplus.Data.execute('_piscopevar=execute($)', expr).data()
# r =MDSplus.Data.execute(expr).data()
# sig_names.append(name)
return r
except:
self.error = ['run error', expr, traceback.format_exc()]
return None
# elif com == 'dim_of': # this is not used anymore
# expr = job.params[0] ### expr should be y, 0 (= dim_of(y, 0))
# dim_names.append(name)
# return expr
elif com == 'script_txt':
return self._run_script_txt(job)
