def test_call_method(self): self.p.create_queue.return_value = queue.Queue() def f(request): request.respond_with_return(dict( greeting="Hello %s" % request.parameters.name)) self.comms.q.put.side_effect = f ret = self.b.say_hello(name="me") self.assertEqual(ret.greeting, "Hello me")
def __init__(self, user_facing=False): self.user_facing = user_facing self.cothread = maybe_import_cothread() if self.cothread: self._event_queue = self.cothread.EventQueue() if user_facing: # Install a signal handler that will make sure we are the # thing that is interrupted def signal_exception(signum, frame): self._event_queue.Signal(self.INTERRUPTED) signal.signal(signal.SIGINT, signal_exception) else: self._queue = queue.Queue()
def setUp(self): self.callback_result = 0 self.callback_value = '' meta = VMeta("meta for unit tests") self.block = MagicMock() self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.attr = Attribute(meta) self.attr.set_parent(self.block, "testAttr") self.attr2 = Attribute(meta) self.attr2.set_parent(self.block, "testAttr2") self.method = Method("method for unit tests") self.method.set_parent(self.block, "testFunc") self.method2 = Method("method for unit tests") self.method2.set_parent(self.block, "testFunc") self.bad_called_back = False
def setUp(self): self.callback_result = 0 self.callback_value = '' meta = StringMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_process_path(self.proc, ("testBlock", )) self.attr = meta.make_attribute() self.attr2 = meta.make_attribute() self.method = MethodMeta("method for unit tests") self.method.returns.set_elements(ElementMap(dict(ret=StringMeta()))) self.method2 = MethodMeta("method for unit tests") self.block.replace_endpoints( dict(testFunc=self.method, testFunc2=self.method2, testAttr=self.attr, testAttr2=self.attr2)) self.bad_called_back = False
def make_async_logging(log_config): # Now we have our user specified logging config, pipe all logging messages # through a queue to make it asynchronous from malcolm.compat import QueueListener, queue import logging.config # These are the handlers for our root logger, they should go through a queue root_handlers = log_config["root"].pop("handlers") # Create a new handler to replace all the above that just pops messages on # a queue, and set it as the handler for the root logger (and children) q = queue.Queue() log_config["handlers"]["queue"] = { "class": "malcolm.compat.QueueHandler", "queue": q} log_config["root"]["handlers"] = ["queue"] logging.config.dictConfig(log_config) # Now make a queue listener that consumes messages on the queue and forwards # them to any of the appropriate original root handlers handlers = [logging._handlers[h] for h in root_handlers] listener = QueueListener(q, *handlers, respect_handler_level=True) return listener
def main(): from malcolm.compat import queue from malcolm.profiler import Profiler args = parse_args() # Make some log config, either fron command line or log_config = make_logging_config(args) # Start it off, and tell it to stop when we quit listener = make_async_logging(log_config) listener.start() atexit.register(listener.stop) # Setup profiler dir profiler = Profiler() # profiler.start() # If using p4p then set cothread to use the right ca libs before it is try: import epicscorelibs.path.cothread except ImportError: pass # Import the Malcolm process q = queue.Queue() t = threading.Thread(target=try_prepare_locals, args=(q, args)) t.start() process = q.get(timeout=65) if isinstance(process, Exception): # Startup failed, exit now sys.exit(1) # Now its safe to import Malcolm and cothread import cothread from malcolm.core import Context from malcolm.modules.builtin.blocks import proxy_block # Make a user context class UserContext(Context): def post(self, path, params=None, timeout=None, event_timeout=None): try: return super(UserContext, self).post(path, params, timeout, event_timeout) except KeyboardInterrupt: self.post([path[0], "abort"]) def _make_proxy(self, comms, mri): self._process.add_controller(proxy_block(comms=comms, mri=mri)[-1]) def make_proxy(self, comms, mri): # Need to do this in cothread's thread cothread.CallbackResult(self._make_proxy, comms, mri) def block_view(self, mri): return cothread.CallbackResult( super(UserContext, self).block_view, mri) def make_view(self, controller, data, child_name): return cothread.CallbackResult( super(UserContext, self).make_view, controller, data, child_name) def handle_request(self, controller, request): cothread.CallbackResult( super(UserContext, self).handle_request, controller, request) self = UserContext(process) header = """Welcome to iMalcolm. self.mri_list: %s Try: hello = self.block_view("HELLO") hello.greet("me") or gui(self.block_view("COUNTER")) or self.make_proxy("localhost:8008", "HELLO") self.block_view("HELLO").greet("me") """ % (self.mri_list, ) try: import IPython except ImportError: import code code.interact(header, local=locals()) else: IPython.embed(header=header) if profiler.running and not profiler.stopping: profiler.stop() cothread.CallbackResult(process.stop) cothread.CallbackResult(cothread.Quit)
def setUp(self): self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(return_value=queue.Queue()) self.task = Task("testTask", self.proc)
def create_queue(self): """Creates a new Queue object""" return queue.Queue()