stop all container created by conu

        :return: None
977280
def cleanup_containers(self):
        
        for cont in self.list_containers():
            if CONU_ARTIFACT_TAG in cont.name:
                try:
                    logger.debug("removing container %s created by conu", cont)
                    # TODO: move this functionality to container.delete
                    run_cmd(["machinectl", "terminate", cont.name])
                except subprocess.CalledProcessError as e:
                    logger.error("unable to remove container %s: %r", cont, e)
1040568
def stop(self):
        """"""
        if self.container_id is None:
            raise Exception('No Docker Selenium container was running')
        check_call(['docker', 'stop', self.container_id])
        self.container_id = None
403063
def stop(cls):
        
        main_log, cls.main_log = cls.main_log, StructuredLogger_usingStream(STDOUT)
        main_log.stop()
187084
async def terminate(self):
        """"""
        # Workaround for pylint issue #1469
        # (https://github.com/PyCQA/pylint/issues/1469).
        cmd = await subprocess.create_subprocess_exec(  # pylint: disable=no-member
            *shlex.split('{} rm -f {}'.format(self.command, self._generate_container_name()))
        )
        await cmd.wait()
        await self.proc.wait()

        await super().terminate()
1041195
def stop(self):
        
        for component in self.components:
            component.close()
            self.log('Stopping component - {}', component.__class__.__name__)

        for controller in self.controllers.values():
            controller.close()
            self.log('Stopping controller - {}', controller.__class__.__name__)

        atexit.unregister(self.stop)
426395
def stop(self):
        
        self._cmds_q.put(("stop",))
        for recorder in self._data_stream_recorders:
            recorder._stop()
        try:
            self._syncer.terminate()
        except Exception:
            pass
1328128
def pop(self):
        '''
        
        '''
        if not self._containers:
            raise KittyException('no container to pop')
        self._containers.pop()
        if self._container():
            self._container().pop()
375886
def stop_cmd(self, name, force):
        
        check_permissions()

        if name:
            echo("Would stop container {0}".format(name))
        else:
            echo("Would stop all containers")
        echo("For now use 'docker stop' to stop the containers")
513662
def stop(self, **kwargs):
        
        for key in kwargs:
            setattr(self, key, kwargs[key])
        self.command = self.COMMAND_STOP
719845
def kill(self):
        '''
        
        '''
        Base.kill(self)
        
        for c in self.containers:
            c.remove_internal(self)
        for w in self.widgets:
            w.remove_internal(self)
408593
private CompletableFuture<Void> stopContainer(int containerId) {
        log.info("Stopping Container {}.", containerId);
        ContainerHandle handle = handles.get(containerId);
        if (handle == null) {
            log.warn("Container {} handle is null, container is pending start or already unregistered.", containerId);
            return null;
        } else {
            this.pendingTasks.add(containerId);
            try {
                return registry
                        .stopContainer(handle, CLOSE_TIMEOUT_PER_CONTAINER)
                        .whenComplete((aVoid, throwable) -> {
                            if (throwable != null) {
                                log.warn("Stopping container {} failed: {}", containerId, throwable);
                            }
                            try {
                                // We remove the handle and don't attempt retry on stop container failures.
                                unregisterHandle(containerId);
                            } finally {
                                // The pending task has to be removed after the handle is removed to avoid inconsistencies
                                // with the container state.
                                // Using finally block to ensure this is always called, otherwise this will prevent other
                                // tasks from being attempted for this container id.
                                this.pendingTasks.remove(containerId);
                            }
                        });
            } catch (Throwable e) {
                // The pending task has to be removed on all failures to enable retries.
                this.pendingTasks.remove(containerId);
                throw e;
            }
        }
    }
40079
def stop(self):
        

        yield from self._stop_ubridge()
        if self._nvram_watcher:
            self._nvram_watcher.close()
            self._nvram_watcher = None

        if self._telnet_server:
            self._telnet_server.close()
            self._telnet_server = None

        if self.is_running():
            self._terminate_process_iou()
            if self._iou_process.returncode is None:
                try:
                    yield from gns3server.utils.asyncio.wait_for_process_termination(self._iou_process, timeout=3)
                except asyncio.TimeoutError:
                    if self._iou_process.returncode is None:
                        log.warning("IOU process {} is still running... killing it".format(self._iou_process.pid))
                        try:
                            self._iou_process.kill()
                        except ProcessLookupError:
                            pass
            self._iou_process = None

        self._started = False
        self.save_configs()
688697
def stop(self, *args, **kwargs):
        
        if args:
            LOG.debug("args: %s" % str(args))
        if kwargs:
            LOG.debug("kwargs: %s" % str(kwargs))
        try:
            self._server.stop()
            self._server = None

            # Device-storage clear
            self.devices.clear()
            self.devices_all.clear()
            self.devices_raw.clear()
            self.devices_raw_dict.clear()

            return True
        except Exception as err:
            LOG.critical("Failed to stop server")
            LOG.debug(str(err))
            return False
3926
def stop(context):
    
    config = context.obj["config"]
    pidfile = select(config, "application.pidfile", DEFAULT_PIDFILE)
    daemon_stop(pidfile)
555037
def destroy(force=false)
      unless exists?
        raise ContainerError, "Container does not exist."
      end

      if running?
        if force == true
          stop
        else
          raise ContainerError, "Container is running. Stop it first or use force=true"
        end  
      end

      run("destroy")

      !exists?
    end
1247756
async def stop(self):
        """"""
        await self._command_task.future_command(['_set_mode', 0, 0])  # Disable advertising
        await self._cleanup_old_connections()

        self._command_task.stop()
        self._stream.stop()
        self._serial_port.close()

        await super(BLED112Server, self).stop()
997224
def stop(self):
        
        if self._fd is not None:
            self._pollobj.unregister(self._fd)
            os.close(self._fd)
            self._fd = None
        self._sys_proc_fun = None