def _setup_proxies(self): logging.debug("Creating proxies") self._baton_binary_proxy_controller = BatonProxyController(self.irods_server, self._baton_docker_build.tag) self.baton_location = self._baton_binary_proxy_controller.create_proxy_binaries() self._icommand_binary_proxy_controller = ICommandProxyController( self.irods_server, self._baton_docker_build.tag) # Make icommand proxy binaries share cached container with baton proxy binaries to get a speedup self._icommand_binary_proxy_controller.cached_container_name = self._baton_binary_proxy_controller.cached_container_name self.icommands_location = self._icommand_binary_proxy_controller.create_proxy_binaries()
class TestWithBaton: """ A setup for testing with baton. """ @unique class _SetupState(Enum): """ States of a `TestWithBaton` instance. """ INIT = 0, RUNNING = 1, STOPPED = 2 def __init__(self, baton_image: BatonImage=DEFAULT_BATON_SETUP.value[0], irods_version_to_start: IrodsVersion=DEFAULT_BATON_SETUP.value[1], irods_server: IrodsServer=None, baton_setup: BatonSetup=None): """ Constructor. :param baton_image: baton Docker image that is to be used :param irods_version_to_start: the version of iRODS to start (if any) :param irods_server: the started iRODS server ot use (if any) :param baton_setup: the baton setup to use (if any) """ if baton_setup is not None: baton_image = baton_setup.value[0] irods_version_to_start = baton_setup.value[1] if irods_version_to_start is None and irods_server is None: raise ValueError("Must either define an iRODs server to use or a version of iRODS that is to be started") if irods_version_to_start is not None and irods_server is not None: raise ValueError("Must either define an iRODs server to use or a version of iRODS to start, not both") # Ensure that no matter what happens, tear down is done atexit.register(self.tear_down) self.irods_server = irods_server self._irods_version_to_start = irods_version_to_start self._state = TestWithBaton._SetupState.INIT self._baton_docker_build = baton_image self.baton_location = None self.icommands_location = None self._baton_binary_proxy_controller = None # type: BatonProxyController self._icommand_binary_proxy_controller = None # type: ICommandProxyController def setup(self): """ Sets up the setup: builds the baton Docker image, starts the iRODS test server (if required) and creates the proxies. """ if self._state != TestWithBaton._SetupState.INIT: raise RuntimeError("Already been setup") self._state = TestWithBaton._SetupState.RUNNING docker_client = create_client() if self._baton_docker_build.docker_file is not None: # baton Docker image is to be built from a local Dockerfile logging.debug("Building baton Docker") build_baton_docker(docker_client, self._baton_docker_build) else: # Ensuring Docker image is pulled - not waiting until `docker run` to prevent Docker from polluting the # stderr if ":" in self._baton_docker_build.tag: repository, tag = self._baton_docker_build.tag.split(":") else: repository = self._baton_docker_build.tag tag = "" docker_image = docker_client.images("%s:%s" % (repository, tag), quiet=True) if len(docker_image) == 0: # Docker image doesn't exist locally: getting from DockerHub docker_client.pull(repository, tag) if self._irods_version_to_start: logging.debug("Starting iRODS test server") self.irods_server = get_static_irods_server_controller(self._irods_version_to_start).start_server() logging.debug("iRODS test server has started") else: logging.debug("Using pre-existing iRODS server") self._setup_proxies() logging.debug("Setup complete") def _setup_proxies(self): logging.debug("Creating proxies") self._baton_binary_proxy_controller = BatonProxyController(self.irods_server, self._baton_docker_build.tag) self.baton_location = self._baton_binary_proxy_controller.create_proxy_binaries() self._icommand_binary_proxy_controller = ICommandProxyController( self.irods_server, self._baton_docker_build.tag) # Make icommand proxy binaries share cached container with baton proxy binaries to get a speedup self._icommand_binary_proxy_controller.cached_container_name = self._baton_binary_proxy_controller.cached_container_name self.icommands_location = self._icommand_binary_proxy_controller.create_proxy_binaries() def tear_down(self): """ Tear down the test environment. """ if self._state == TestWithBaton._SetupState.RUNNING: self._state = TestWithBaton._SetupState.STOPPED atexit.unregister(self.tear_down) if self._irods_version_to_start is not None: logging.debug("Stopping iRODS server") get_static_irods_server_controller(self._irods_version_to_start).stop_server(self.irods_server) self.irods_server = None else: logging.debug("External iRODS test server used - not tearing down") logging.debug("Tearing down binary proxies") self._tear_down_proxies() self.baton_location = None self.icommands_location = None logging.debug("Tear down complete") def _tear_down_proxies(self): """ Tears down the baton and icommand proxy binaries. """ if self._baton_binary_proxy_controller is not None: self._baton_binary_proxy_controller.tear_down() if self._icommand_binary_proxy_controller is not None: self._icommand_binary_proxy_controller.tear_down()