Inheritance diagram for microscope.device_server.DeviceServer:

Public Member Functions
def	__init__ (self, device_def, DeviceServerOptions options, typing.Mapping[str, str] id_to_host, typing.Mapping[str, int] id_to_port, typing.Optional[multiprocessing.Event] exit_event=None)

def	clone (self)

def	run (self)

Public Attributes
	exit_event

	daemon

Detailed Description

Initialise a device and serve at host/port according to its id.

Args:
    device_def: definition of the device.
    options: configuration for the device server.
    id_to_host: host or mapping of device identifiers to hostname.
    id_to_port: map or mapping of device identifiers to port
        number.
    exit_event: a shared event to signal that the process should
        quit.

Definition at line 241 of file device_server.py.

Constructor & Destructor Documentation

◆ init()

def microscope.device_server.DeviceServer.__init__	(		self,
			device_def,
		DeviceServerOptions	options,
		typing.Mapping[str, str]	id_to_host,
		typing.Mapping[str, int]	id_to_port,
		typing.Optional[multiprocessing.Event]	exit_event = `None`
	)

Definition at line 255 of file device_server.py.

    ):
        # The device to serve.
        self._device_def = device_def
        self._options = options
        self._devices: typing.Dict[str, microscope.abc.Device] = {}
        # Where to serve it.
        self._id_to_host = id_to_host
        self._id_to_port = id_to_port
        # A shared event to allow clean shutdown.
        self.exit_event = exit_event
        super().__init__()
        self.daemon = True
 

Member Function Documentation

◆ clone()

def microscope.device_server.DeviceServer.clone ( self )

Create new instance with same settings.

This is useful to restart a device server.

Definition at line 275 of file device_server.py.

    def clone(self):
        """Create new instance with same settings.
 
        This is useful to restart a device server.
 
        """
        return DeviceServer(
            self._device_def,
            self._options,
            self._id_to_host,
            self._id_to_port,
            exit_event=self.exit_event,
        )
 

References microscope.device_server.DeviceServer._device_def, microscope.device_server.DeviceServer._devices, microscope.simulators.SimulatedController._devices, microscope.device_server.DeviceServer._id_to_host, microscope.device_server.DeviceServer._id_to_port, microscope.device_server.DeviceServer._options, and microscope.device_server.DeviceServer.exit_event.

◆ run()

def microscope.device_server.DeviceServer.run ( self )

Definition at line 289 of file device_server.py.

    def run(self):
        cls = self._device_def["cls"]
        cls_name = cls.__name__
 
        # If the multiprocessing start method is fork, the child
        # process gets a copy of the root logger.  The copy is
        # configured to sign the messages as "device-server", and
        # write to the main log file and stderr.  We remove those
        # handlers so that this DeviceServer is logged to a separate
        # file and the messages are signed with the device name.
        root_logger = logging.getLogger()
        # Get a new list of handlers because otherwise we are
        # iterating over the same list as removeHandler().
        for handler in list(root_logger.handlers):
            root_logger.removeHandler(handler)
 
        root_logger.setLevel(self._options.logging_level)
 
        # Later, we'll log to one file per server, with a filename
        # based on a unique identifier for the device. Some devices
        # don't have UIDs available until after initialization, so
        # log to stderr until then.
        stderr_handler = StreamHandler(sys.stderr)
        stderr_handler.setFormatter(_create_log_formatter(cls_name))
        root_logger.addHandler(stderr_handler)
        root_logger.debug("Debugging messages on.")
 
        root_logger.addFilter(Filter())
 
        # The cls argument can either be a Device subclass, or it can
        # be a function that returns a map of names to devices.
        cls_is_type = isinstance(cls, type)
 
        if not cls_is_type:
            self._devices = cls(**self._device_def["conf"])
        else:
            while not self.exit_event.is_set():
                try:
                    device = cls(**self._device_def["conf"])
                except Exception as e:
                    _logger.info(
                        "Failed to start device. Retrying in 5s.", exc_info=e
                    )
                    time.sleep(5)
                else:
                    break
            self._devices = {cls_name: device}
 
        if cls_is_type and issubclass(cls, FloatingDeviceMixin):
            uid = str(list(self._devices.values())[0].get_id())
            if uid not in self._id_to_host or uid not in self._id_to_port:
                raise Exception(
                    "Host or port not found for device %s" % (uid,)
                )
            host = self._id_to_host[uid]
            port = self._id_to_port[uid]
        else:
            host = self._device_def["host"]
            port = self._device_def["port"]
 
        pyro_daemon = Pyro4.Daemon(port=port, host=host)
 
        log_handler = RotatingFileHandler(
            "%s_%s_%s.log" % (cls_name, host, port)
        )
        log_handler.setFormatter(_create_log_formatter(cls_name))
        root_logger.addHandler(log_handler)
 
        _logger.info("Device initialized; starting daemon.")
        for obj_id, device in self._devices.items():
            _register_device(pyro_daemon, device, obj_id=obj_id)
 
        # Run the Pyro daemon in a separate thread so that we can do
        # clean shutdown under Windows.
        pyro_thread = Thread(target=pyro_daemon.requestLoop)
        pyro_thread.daemon = True
        pyro_thread.start()
        for device in self._devices.values():
            _logger.info("Serving %s", pyro_daemon.uriFor(device))
            if isinstance(device, FloatingDeviceMixin):
                _logger.info(
                    "Device UID on port %s is %s", port, device.get_id()
                )
 
        # Wait for termination event. We should just be able to call
        # wait() on the exit_event, but this causes issues with locks
        # in multiprocessing - see http://bugs.python.org/issue30975 .
        while self.exit_event and not self.exit_event.is_set():
            # This tread waits for the termination event.
            try:
                time.sleep(5)
            except (KeyboardInterrupt, IOError):
                pass
        pyro_daemon.shutdown()
        pyro_thread.join()
        for device in self._devices.values():
            try:
                device.shutdown()
            except Exception as ex:
                # Catch errors so we get a chance of shutting down the
                # other devices.
                _logger.error("Failure to shutdown device %s", device, ex)
 
 

Member Data Documentation

◆ daemon

microscope.device_server.DeviceServer.daemon

Definition at line 273 of file device_server.py.

◆ exit_event

microscope.device_server.DeviceServer.exit_event

Definition at line 271 of file device_server.py.

Referenced by microscope.device_server.DeviceServer.clone().

The documentation for this class was generated from the following file:

F:/repos/BioImager/BioImager/PythonMicroscope/microscope/device_server.py

Public Member Functions

Public Attributes