SwissFEL/morbidissimo
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed test code from prototyping

Browse Source
This commit is contained in:
augustin_s
2021-03-09 18:56:50 +01:00
parent 094e6a7f7c
commit 653f8d942e
9 changed files with 0 additions and 623 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
modman/executing.py
View File

@ -1,21 +0,0 @@
from concurrent.futures import ThreadPoolExecutor
class Executor(ThreadPoolExecutor):
def __init__(self):
super().__init__()
self.futures = {}
def run(self, name, func, *args, **kwargs):
fut = self.submit(func, *args, **kwargs)
self.futures[name] = fut
return fut
def cleanup(self):
for name, fut in tuple(self.futures.items()):
if fut.done():
del self.futures[name]

37
morioc/experiments/dummy.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python
from pcaspy import Driver, SimpleServer
prefix = 'MTEST:'
pvdb = {
'RAND' : {
'prec' : 3,
},
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
if __name__ == '__main__':
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
# process CA transactions
for i in range(100):
server.process(0.1)
print(1)
del server
print(2)
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
# process CA transactions
for i in range(100):
server.process(0.1)

57
morioc/experiments/dummy2.py
View File

@ -1,57 +0,0 @@
#!/usr/bin/env python
from pcaspy import Driver, SimpleServer
prefix1 = 'MTEST1:'
pvdb1 = {
'RAND1' : {
'prec' : 3,
},
}
prefix2 = 'MTEST1:' #!!!
pvdb2 = {
'RAND2' : {
'prec' : 3,
},
}
prefix3 = 'MTEST3:'
pvdb3 = {
'RAND3' : {
'prec' : 3,
},
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
if __name__ == '__main__':
server = SimpleServer()
server.createPV(prefix1, pvdb1)
driver = myDriver()
print(1)
for i in range(300):
server.process(0.1)
server.createPV(prefix2, pvdb2)
driver = myDriver()
print(2)
for i in range(300):
server.process(0.1)
server.createPV(prefix3, pvdb3)
driver = myDriver()
print(3)
for i in range(300):
server.process(0.1)

122
morioc/experiments/dummy3.py
View File

@ -1,122 +0,0 @@
#!/usr/bin/env python
from time import sleep
import random
from threading import Thread
from pcaspy import Driver, SimpleServer
from pcaspy.driver import manager
prefix1 = 'MTEST1:'
pvdb1 = {
'RAND1' : {
'prec' : 3,
},
}
prefix2 = 'MTEST2:'
pvdb2 = {
'RAND2' : {
'prec' : 3,
},
}
prefix3 = 'MTEST3:'
pvdb3 = {
'RAND3' : {
'prec' : 3,
},
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
def read(self, reason):
if reason.startswith('RAND'):
value = random.random()
else:
value = self.getParam(reason)
return value
class Mor:
def __init__(self, prefix, pvdb, wait_time=0.1):
self.wait_time = wait_time
self.server = SimpleServer()
self.server.createPV(prefix, pvdb)
self.driver = myDriver()
self.thread = Thread(target=self.run)
self.thread.start()
def run(self):
self.processing = True
self.running = True
n = 0
while self.running:
n += 1
if self.processing:
# print("proc", n)
self.server.process(self.wait_time)
else:
# print("pause proc", n)
sleep(self.wait_time)
def stop(self):
self.running = False
self._sleep_after_change()
def stop_proc(self):
self.processing = False
self._sleep_after_change()
def start_proc(self):
self.processing = True
self._sleep_after_change()
def _sleep_after_change(self):
wait_time = self.wait_time * 1.1
sleep(wait_time)
def createPV(self, prefix, pvdb):
# self.stop_proc()
self.server.createPV(prefix, pvdb)
self.driver = myDriver()
# self.start_proc()
def deletePV(self, prefix, pvdb):
# self.stop_proc()
for n in pvdb:
del manager.pvs["default"][n]
del manager.pvf[prefix + n]
# self.start_proc()
if __name__ == '__main__':
print("create", 1)
mor = Mor(prefix1, pvdb1)
sleep(15)
print("create", 2)
mor.createPV(prefix2, pvdb2)
sleep(15)
print("delete", 2)
mor.deletePV(prefix2, pvdb2)
sleep(15)
print("create", 2)
mor.createPV(prefix2, pvdb2)
sleep(15)
print("create", 3)
mor.createPV(prefix3, pvdb3)
sleep(15)
mor.stop()

50
morioc/experiments/example.py
View File

@ -1,50 +0,0 @@
#!/usr/bin/env python
from pcaspy import Driver
from mor import Mor
prefix = 'MTEST:'
pvdb = {
'RAND' : {
'prec' : 3,
},
"NAME" : {
"type": "string"
}
}
class myDriver(Driver):
def __init__(self, server):
self.server = server
super(myDriver, self).__init__()
def write(self, reason, value):
print("write", reason, value)
if reason == "NAME":
new_pvdb = {
value: {
"type": "int"
}
}
self.server.createPV(new_pvdb)
# self.server.restart()
return super().write(reason, value)
def read(self, reason):
value = self.getParam(reason)
print("read", reason, value)
return super().read(reason)
if __name__ == '__main__':
server = Mor(prefix, pvdb, myDriver)
# server.createPV(pvdb)

129
morioc/experiments/ign/morioc-bak1.py
View File

@ -1,129 +0,0 @@
from time import sleep
from datetime import datetime
from threading import Thread
from pcaspy import SimpleServer, Driver
from pcaspy.driver import manager, _ait_d as AIT_D
from context import Context
from utils import typename
INITIAL_PVDB = {
"START_TIME" : {
"type": "string"
}
}
D_AIT = {v:k for k, v in AIT_D.items()}
class DefaultDriver(Driver): #TODO: caget on START_TIME crashes without this subclass?!
pass
class MorIOC(Context):
def __init__(self, prefix, DriverClass=DefaultDriver, wait_time=0.1):
print("init")
prefix = prefix.upper()
prefix = prefix if prefix.endswith(":") else prefix + ":"
self.prefix = prefix
self.DriverClass = DriverClass
self.wait_time = wait_time
self.server = SimpleServer()
self.server.createPV(prefix, INITIAL_PVDB)
self.driver = DriverClass()
now = datetime.now()
self.driver.setParam("START_TIME", str(now))
self.driver.updatePVs()
self.thread = Thread(target=self.run, daemon=True)
self.thread.start()
def run(self):
self.processing = True
self.running = True
n = 0
while self.running:
n += 1
if self.processing:
# print("proc", n)
self.server.process(self.wait_time)
else:
# print("pause proc", n)
sleep(self.wait_time)
def stop(self):
self.running = False
self._sleep_after_change()
# def stop_proc(self):
# self.processing = False
# self._sleep_after_change()
# def start_proc(self):
# self.processing = True
# self._sleep_after_change()
def _sleep_after_change(self):
wait_time = self.wait_time * 1.1
sleep(wait_time)
def createPV(self, pvdb):
# self.stop_proc()
current_pvdb = self.driver.pvDB #TODO crash due to keyerror otherwise
self.server.createPV(self.prefix, pvdb)
self.driver = self.DriverClass()
self.driver.pvDB.update(current_pvdb)
# self.start_proc()
def deletePVs(self, pvdb):
# self.stop_proc()
for n in pvdb:
self.deletePV(n)
# self.start_proc()
def deletePV(self, name):
del manager.pvs["default"][name]
del manager.pvf[self.prefix + name]
def serve(self, **kwargs):
pvdb = {}
for name, value in kwargs.items():
name = name.upper()
dtype = typename(value)
if not name in manager.pvs["default"]:
print("will create", name)
pvdb[name] = {"type": dtype}
else:
pv = manager.pvs["default"][name]
pv_type = pv.info.type
pv_type = D_AIT[pv_type]
if pv_type != dtype:
print(f"type for {name} changed:", pv_type, "->", dtype) #TODO what should be done if this happens?
# self.deletePV(name)
# pvdb[name] = {"type": dtype}
if pvdb:
print("new PVs", pvdb)
self.createPV(pvdb)
for name, value in kwargs.items():
name = name.upper()
self.driver.setParam(name, value)
self.driver.updatePVs()
def host(self, **kwargs):
pass
#TODO:
# - if pv name already contains :, don't prepend prefix?!

74
morioc/experiments/ign/run_old1.py
View File

@ -1,74 +0,0 @@
#!/usr/bin/env python
from time import sleep
from random import random, randint
from pcaspy import Driver
from morioc import MorIOC
pvdb1 = {
'RAND1' : {
'prec' : 3,
},
}
pvdb2 = {
'RAND2' : {
'prec' : 3,
},
}
pvdb3 = {
'RAND3' : {
'prec' : 3,
},
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
def read(self, reason):
if reason.startswith('RAND'):
value = random()
# self.setParam(reason, value)
# self.updatePVs()
else:
value = self.getParam(reason)
return value
if __name__ == '__main__':
print("init")
mor = MorIOC("mtest", DriverClass=myDriver)
sleep(3)
print("create", 1)
mor.createPV(pvdb1)
sleep(3)
print("create", 2)
mor.createPV(pvdb2)
sleep(3)
print("delete", 2)
mor.deletePVs(pvdb2)
sleep(3)
print("create", 2)
mor.createPV(pvdb2)
sleep(3)
print("create", 3)
mor.createPV(pvdb3)
sleep(3)
mor.stop()

30
morioc/experiments/ign/run_old2.py
View File

@ -1,30 +0,0 @@
#!/usr/bin/env python
from time import sleep
from random import random, randint
from morioc import MorIOC
if __name__ == "__main__":
mor = MorIOC("mtest")
for i in range(100):
mor.serve(
rand1 = random(),
rand2 = randint(100, 200),
rand3 = random() + 10
)
sleep(0.5)
# mor.serve(
# rand1 = random(),
# rand3 = randint(100, 200),
# rand2 = random() + 10
# )
# sleep(0.5)
mor.stop()

103
morioc/experiments/mor.py
View File

@ -1,103 +0,0 @@
#!/usr/bin/env python
import gc
from time import sleep
from pcaspy import SimpleServer
from pcaspy.tools import ServerThread
from pcaspy.driver import cas
class KillWrapper:
def __init__(self, Wrapped, *args, **kwargs):
print("init")
self.Wrapped = Wrapped
self.args = args
self.kwargs = kwargs
self.init()
def init(self):
self.wrapped = self.Wrapped(*self.args, **self.kwargs)
def kill(self):
print("del")
del self.wrapped
sleep(1)
self.wrapped = None
sleep(1)
print("del'ed")
gc.collect()
sleep(2)
print("gc'ed")
self.init()
def __getattr__(self, name):
return getattr(self.wrapped, name)
class Mor:
def __init__(self, prefix, pvdb, Driver):
self.prefix = prefix
self.Driver = Driver
self.server = None
self.driver = None
self.running = False
self.pvdb = pvdb
self.start()
def restart(self):
print("restart")
self.process = True
def start(self):
print("start")
self.server = server = KillWrapper(SimpleServer)
# server.setDebugLevel(4)
print(self.pvdb)
server.createPV(self.prefix, self.pvdb)
self.driver = KillWrapper(self.Driver, self)
# print("thread start")
# self.thread = thread = ServerThread(server)
# thread.start()
print("wait loop")
self.process = True
self.running = True
while self.running:
if self.process:
server.process(0.1)
def stop(self):
print("stop")
# self.thread.stop()
# sleep(1)
# print(self.thread)
# del self.thread
# self.thread = None
self.process = False
sleep(0.2)
# del self.driver.server
# del self.driver
# self.driver = None
self.driver.kill()
self.server.kill()
# del self.server
# self.server = None
# gc.collect()
# print("sleeping start")
# sleep(2)
# print("sleeping done")
def createPV(self, new_pvdb):
print("createPV")
self.stop()
# self.pvdb.update(new_pvdb)
print(self.pvdb)
self.restart()