def prepare_locals(args):
from malcolm.core import Process
from malcolm.yamlutil import make_include_creator
if args.yaml:
proc_name = os.path.basename(args.yaml).split(".")[-2]
proc = Process(proc_name)
controllers, parts = make_include_creator(args.yaml)()
assert not parts, "%s defines parts" % (args.yaml, )
for controller in controllers:
proc.add_controller(controller)
proc_name = "%s - imalcolm" % proc_name
else:
proc = Process("Process")
proc_name = "imalcolm"
# set terminal title
sys.stdout.write("\x1b]0;%s\x07" % proc_name)
if args.client:
if args.client.startswith("ws://"):
from malcolm.modules.web.controllers import WebsocketClientComms
hostname, port = args.client[5:].split(":")
comms = WebsocketClientComms(mri="%s:%s" % (hostname, port),
hostname=hostname,
port=int(port))
elif args.client == "pva":
from malcolm.modules.pva.controllers import PvaClientComms
comms = PvaClientComms(mri="pva")
else:
raise ValueError("Don't know how to create client to %s" %
args.client)
proc.add_controller(comms)
proc.start(timeout=60)
return proc
def setUp(self):
self.process = Process("proc")
for controller in motion_block(
mri="TESTMOTION",
config_dir="/tmp") + pva_server_block(mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in pva_client_block(mri="PVA-CLIENT") + proxy_block(
mri="TESTMOTION", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
def setUp(self):
self.process = Process("proc")
for controller in \
ticker_block(mri="TICKER", config_dir="/tmp") + \
pva_server_block(mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in \
pva_client_block(mri="PVA-CLIENT") + \
proxy_block(mri="TICKER", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
def setUp(self):
self.process = Process("proc")
for controller in detector_block(
mri="TESTDET",
config_dir="/tmp") + pva_server_block(mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in pva_client_block(mri="PVA-CLIENT") + proxy_block(
mri="TESTDET", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
self.tmpdir = tempfile.mkdtemp()
def setUp(self):
self.process = Process("proc")
self.hello = call_with_params(hello_block, self.process, mri="hello")
self.counter = call_with_params(
counter_block, self.process, mri="counter")
self.server = call_with_params(
web_server_block, self.process, mri="server", port=self.socket)
self.process.start()
self.process2 = Process("proc2")
self.client = call_with_params(
websocket_client_block, self.process2, mri="client",
port=self.socket)
self.process2.start()
def setUp(self):
self.process = Process("proc")
for controller in (hello_block(mri="hello") +
counter_block(mri="counter") +
web_server_block(mri="server", port=self.socket)):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in (
websocket_client_block(mri="client", port=self.socket) +
proxy_block(mri="hello", comms="client") +
proxy_block(mri="counter", comms="client")):
self.process2.add_controller(controller)
self.process2.start()
def setUp(self):
self.sf = SyncFactory("sync")
self.process = Process("proc", self.sf)
DefaultController("hello",
self.process,
parts=dict(hello=HelloPart(self.process, None)))
DefaultController("counter",
self.process,
parts=dict(counter=CounterPart(self.process, None)))
WebsocketServerComms(self.process, dict(port=self.socket))
self.process.start()
self.process2 = Process("proc2", self.sf)
WebsocketClientComms(self.process2,
dict(hostname="localhost", port=self.socket))
self.process2.start()
def setUp(self):
sf = SyncFactory("sync")
self.process = Process("proc", sf)
Hello(self.process, dict(mri="hello"))
Counter(self.process, dict(mri="counter"))
self.process.add_comms(
WebsocketServerComms(self.process, dict(port=self.socket)))
self.process.start()
# If we don't wait long enough, sometimes the websocket_connect()
# in process2 will hang...
time.sleep(0.1)
self.process2 = Process("proc2", sf)
self.process2.add_comms(
WebsocketClientComms(self.process2,
dict(hostname="localhost", port=self.socket)))
self.process2.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(odin_writer_block,
self.process,
mri="mri",
prefix="prefix")
self.mock_when_value_matches(self.child)
# set up some values for OdinData PVs that Excalibur would have
settings = {
"imageHeight": 1536,
"imageWidth": 1048,
"blockSize": 1,
"numProcesses": 4,
"dataType": "uint16",
}
self.set_attributes(self.child, **settings)
self.o = OdinWriterPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
self.completed_steps = 0
# goal for these is 3000, 2000, True
cols, rows, alternate = 3000, 2000, False
self.steps_to_do = cols * rows
xs = LineGenerator("x", "mm", 0.0, 0.5, cols, alternate=alternate)
ys = LineGenerator("y", "mm", 0.0, 0.1, rows)
self.generator = CompoundGenerator([ys, xs], [], [], 0.1)
self.generator.prepare()
def setUp(self):
self.process = Process("proc")
self.hello = call_with_params(hello_block, self.process, mri="hello")
self.server = call_with_params(
web_server_block, self.process, mri="server", port=self.socket)
self.result = Queue()
self.process.start()
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a ticker_block block to act as our child
for c in ticker_block(mri="childBlock", config_dir="/tmp"):
self.p.add_controller(c)
self.b_child = self.context.block_view("childBlock")
# Make an empty part for our parent
part1 = Part("part1")
# Make a RunnableChildPart to control the ticker_block
part2 = RunnableChildPart(mri='childBlock',
name='part2',
initial_visibility=True)
# create a root block for the RunnableController block to reside in
self.c = RunnableController(mri='mainBlock', config_dir="/tmp")
self.c.add_part(part1)
self.c.add_part(part2)
self.p.add_controller(self.c)
self.b = self.context.block_view("mainBlock")
self.ss = self.c.state_set
# start the process off
self.checkState(self.ss.DISABLED)
self.p.start()
self.checkState(self.ss.READY)
def setUp(self):
self.p = Process('process1', SyncFactory('threading'))
# create a child ManagerController block
params = ManagerController.MethodMeta. \
prepare_input_map(mri='childBlock', configDir="/tmp")
self.c_child = ManagerController(self.p, [], params)
self.b_child = self.c_child.block
self.sm = self.c_child.stateMachine
params = Part.MethodMeta.prepare_input_map(name='part1')
part1 = Part(self.p, params)
params = {'name': 'part2', 'mri': 'childBlock'}
params = ChildPart.MethodMeta.prepare_input_map(**params)
part2 = ChildPart(self.p, params)
# create a root block for the ManagerController block to reside in
parts = [part1, part2]
params = ManagerController.MethodMeta.prepare_input_map(
mri='mainBlock', configDir="/tmp")
self.c = ManagerController(self.p, parts, params)
self.b = self.c.block
# check that do_initial_reset works asynchronously
self.p.start()
# wait until block is Ready
task = Task("block_ready_task", self.p)
task.when_matches(self.b["state"], self.sm.READY, timeout=1)
self.checkState(self.sm.READY)
def setUp(self):
self.p = Process("proc")
for c in detector_block("mri", config_dir="/tmp"):
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
self.tmpdir = tempfile.mkdtemp()
def test_caput_status_pv_message(self, catools):
p = self.create_part(
dict(
name="mname",
description="desc",
pv="pv",
status_pv="spv",
good_status="All Good",
message_pv="mpv",
)
)
catools.caget.return_value = [caint(4)]
c = StatefulController("mri")
c.add_part(p)
proc = Process("proc")
proc.add_controller(c)
proc.start()
self.addCleanup(proc.stop)
b = proc.block_view("mri")
self.make_camonitor_return(catools, "No Good")
catools.caget.return_value = "Bad things happened"
with self.assertRaises(AssertionError) as cm:
b.mname()
assert (
str(cm.exception) == "Status No Good: Bad things happened: "
"while performing 'caput pv 1'"
)
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(stats_plugin_block,
self.process,
mri="BLOCK:STAT",
prefix="prefix")
def setUp(self):
self.p = Process("process1")
self.context = Context(self.p)
self.c1 = RunnableController(mri="SYS", config_dir="/tmp")
self.tmp_dir = f"/tmp/{now}-{os.getpid()}"
os.mkdir(self.tmp_dir)
os.mkdir(self.tmp_dir + "/configure")
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
pmac_block = make_block_creator(__file__,
"test_pmac_manager_block.yaml")
self.child = self.create_child_block(pmac_block,
self.process,
mri_prefix="PMAC",
config_dir="/tmp")
# These are the child blocks we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
# self.child_y = self.process.get_controller(
# "BL45P-ML-STAGE-01:Y")
self.child_cs1 = self.process.get_controller("PMAC:CS1")
self.child_traj = self.process.get_controller("PMAC:TRAJ")
self.child_status = self.process.get_controller("PMAC:STATUS")
# CS1 needs to have the right port otherwise we will error
self.set_attributes(self.child_cs1, port="CS1")
self.o = BeamSelectorPart(
name="beamSelector",
mri="PMAC",
selectorAxis="x",
tomoAngle=0,
diffAngle=0.5,
moveTime=0.5,
)
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
pass
def setUp(self):
self.maxDiff = 5000
self.p = Process('process1', SyncFactory('threading'))
# Make a ticker block to act as our child
params = Ticker.MethodMeta.prepare_input_map(mri="childBlock",
configDir="/tmp")
self.b_child = Ticker(self.p, params)[-1]
# Make an empty part for our parent
params = Part.MethodMeta.prepare_input_map(name='part1')
part1 = Part(self.p, params)
# Make a RunnableChildPart to control the ticker
params = RunnableChildPart.MethodMeta.prepare_input_map(
mri='childBlock', name='part2')
part2 = RunnableChildPart(self.p, params)
# create a root block for the RunnableController block to reside in
params = RunnableController.MethodMeta.prepare_input_map(
mri='mainBlock', configDir="/tmp")
self.c = RunnableController(self.p, [part1, part2], params)
self.b = self.c.block
self.sm = self.c.stateMachine
# start the process off
self.p.start()
# wait until block is Ready
task = Task("block_ready_task", self.p)
task.when_matches(self.b["state"], self.sm.IDLE, timeout=1)
self.checkState(self.sm.IDLE)
def setUp(self):
self.process = Process("proc")
self.comms = MagicMock()
self.comms.mri = "comms"
self.process.add_controller(self.comms)
self.o = ProxyController(mri="mri", comms="comms")
self.process.add_controller(self.o)
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a fast child
c1 = call_with_params(RunnableController, self.p,
[WaitingPart("p", 0.01)],
mri="fast", configDir="/tmp")
self.p.add_controller("fast", c1)
# And a slow one
c2 = call_with_params(RunnableController, self.p,
[WaitingPart("p", 1.0)],
mri="slow", configDir="/tmp")
self.p.add_controller("slow", c2)
# And a top level one
p1 = call_with_params(RunnableChildPart, name="FAST", mri="fast")
p2 = call_with_params(RunnableChildPart, name="SLOW", mri="slow")
c3 = call_with_params(RunnableController, self.p, [p1, p2],
mri="top", configDir="/tmp")
self.p.add_controller("top", c3)
self.b = self.context.block_view("top")
self.bf = self.context.block_view("fast")
self.bs = self.context.block_view("slow")
# start the process off
self.p.start()
def setUp(self):
self.sf = SyncFactory("sync")
self.process = Process("proc", self.sf)
part = HelloPart(self.process, None)
DefaultController("hello", self.process, parts={"hello": part})
WebsocketServerComms(self.process, dict(port=self.socket))
self.process.start()
def setUp(self):
self.p = Process('process1')
# create a child to client
self.c_part = MyPart("cp1")
self.c_child = call_with_params(StatefulController,
self.p, [self.c_part],
mri="childBlock")
self.p.add_controller("childBlock", self.c_child)
part1 = MyPart("part1")
part2 = call_with_params(ChildPart, name='part2', mri='childBlock')
# create a root block for the ManagerController block to reside in
parts = [part1, part2]
self.c = call_with_params(ManagerController,
self.p,
parts,
mri='mainBlock',
configDir="/tmp")
self.p.add_controller("mainBlock", self.c)
# check that do_initial_reset works asynchronously
assert self.c.state.value == "Disabled"
self.p.start()
assert self.c.state.value == "Ready"
def setUp(self):
self.p = Process('process1', SyncFactory('threading'))
self.p1, self.c1 = self.makeChildBlock('child1')
self.p2, self.c2 = self.makeChildBlock('child2')
self.p3, self.c3 = self.makeChildBlock('child3')
# create a root block for the child blocks to reside in
parts = [self.p1, self.p2, self.p3]
params = RunnableController.MethodMeta.prepare_input_map(
mri='mainBlock', configDir="/tmp")
self.c = RunnableController(self.p, parts, params)
self.b = self.c.block
params = ChildPart.MethodMeta.prepare_input_map(mri='mainBlock',
name='mainPart')
self.part = ChildPart(self.p, params)
# Get the parent block into idle state
self.p.start()
# wait until block is Ready
task = Task("block_ready_task", self.p)
task.when_matches(self.c.block["state"], sm.IDLE, timeout=1)
self.checkState(sm.IDLE)
def setUp(self):
self.process = Process("proc")
self.part = MyPart("test_part")
self.o = Controller("mri")
self.o.add_part(self.part)
self.process.add_controller(self.o)
self.process.start()
def setUp(self):
self.p = Process("proc")
c = BasicController("mri")
c.add_part(CounterPart(name='counting'))
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a ticker_block block to act as our child
self.c_child = call_with_params(ticker_block,
self.p,
mri="childBlock",
configDir="/tmp")
self.b_child = self.context.block_view("childBlock")
# Make an empty part for our parent
part1 = Part("part1")
# Make a RunnableChildPart to control the ticker_block
part2 = call_with_params(RunnableChildPart,
mri='childBlock',
name='part2')
# create a root block for the RunnableController block to reside in
self.c = call_with_params(RunnableController,
self.p, [part1, part2],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
self.ss = self.c.stateSet
# start the process off
self.checkState(self.ss.DISABLED)
self.p.start()
self.checkState(self.ss.READY)
def setUp(self):
self.config_dir = tmp_dir("config_dir")
self.process = Process("proc")
self.o = ProcessController("MyMRI", self.prefix, self.config_dir.value)
self.process.add_controller(self.o)
self.process.start()
self.b = self.process.block_view("MyMRI")
def setUp(self):
self.process = Process("proc")
self.o = RawMotorSinkPortsPart("PV:PRE")
c = StatefulController("mri")
c.add_part(self.o)
self.process.add_controller(c)
self.b = self.process.block_view("mri")
self.addCleanup(self.process.stop)
def setUp(self):
self.process = Process("proc")
self.o = call_with_params(MQTTServerComms,
self.process, (),
mri="mri",
block="block",
attribute="attribute",
topic_prefix="prefix")
def setUp(self):
self.process = Process("proc")
self.part = MyPart("test_part")
self.controller = Controller("mri")
self.controller.add_part(self.part)
self.process.add_controller(self.controller)
self.block = self.controller.block_view()
self.process.start()
