remove provided container from filesystem

        :param container_id: str
        :param force: bool, remove forcefully?
        :return: None
546300
def remove_container(self, container_id, force=False):
        
        logger.info("removing container '%s' from filesystem", container_id)
        logger.debug("container_id = '%s'", container_id)
        self.d.remove_container(container_id, force=force)
920557
def clear(self) -> None:
        
        logger.debug("clearing all running containers")
        all_uids = [uid for uid in self.__containers.keys()]
        for uid in all_uids:
            try:
                del self[uid]
            except KeyError:
                # Already deleted
                pass
        logger.debug("cleared all running containers")
1325208
def container_destroy(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/destroy' % object_id, input_params, always_retry=always_retry, **kwargs)
825240
def disconnect(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/disconnect/')
518205
def rm(name):
    
    path = get_existing_project_path(name)

    click.confirm(
        'Are you sure you want to delete project %s?' % name, abort=True)

    container_name = get_container_name(name)
    client = docker.Client()
    try:
        client.inspect_container(container_name)
    except docker.errors.NotFound:
        pass
    else:
        print("Removing container %s..." % container_name)
        client.remove_container(container_name, v=True, force=True)

    print("Removing %s..." % path)
    shutil.rmtree(path)
800124
def delete_efs_by_id(efs_id):
  """"""
  start_time = time.time()
  efs_client = get_efs_client()
  sys.stdout.write("deleting %s ... " % (efs_id,))
  while True:
    try:
      response = efs_client.delete_file_system(FileSystemId=efs_id)
      if is_good_response(response):
        print("succeeded")
        break
      time.sleep(RETRY_INTERVAL_SEC)
    except Exception as e:
      print("Failed with %s" % (e,))
      if time.time() - start_time - RETRY_INTERVAL_SEC < RETRY_TIMEOUT_SEC:
        print("Retrying in %s sec" % (RETRY_INTERVAL_SEC,))
        time.sleep(RETRY_INTERVAL_SEC)
      else:
        print("Giving up")
        break
1232866
def detach(self, volume_id, instance_id='', device_path='', force=False):
        """"""
        return self.call("DetachVolume",
                         VolumeId=volume_id, InstanceId=instance_id,
                         Device=device_path, force=force)
1098582
def delete!(force = false)
      if local?
        @lib.branch(@name, :force => force, :delete => true)
      else
        @lib.push(Process.server_name, nil, nil, :delete => @name)
      end
    end
1210026
public function deleteContainer($container, $force = false)
    {
        try {
            $this->checkConnection();
            $this->blobConn->deleteContainer($container);
        } catch (\Exception $ex) {
            if (false === stripos($ex->getMessage(), 'does not exist')) {
                throw $ex;
            }
        }
    }
983034
synchronized Container removeAndGet(final String containerId) {
    final Container result = this.containers.remove(containerId);
    if (null == result) {
      throw new RuntimeException("Unknown container to remove: " + containerId);
    }
    return result;
  }
312334
async def remove(self, *, node_id: str, force: bool = False) -> Mapping[str, Any]:
        

        params = {"force": force}

        response = await self.docker._query_json(
            "nodes/{node_id}".format(node_id=node_id), method="DELETE", params=params
        )
        return response
1318810
public void deleteService(String id, boolean force) {
        try {
            if (id == null || id.isEmpty()) {
                id = selectRunningService();
            }
            final String idFinal = id;
            int input = 'Y';
            if (!force) {
                OutputStreamFormater.printValue(String.format(
                    "Do you really want to delete the connector: %s (Y/n): ", id));
                input = keyboard.read();
            }
            if ('n' != (char) input && 'N' != (char) input) {
                SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        serviceManager.delete(idFinal);
                        return null;
                    }
                });
                OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.err.println("Could not delete service");
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Unexpected Error");
        }
    }
513247
void release(final String containerId) {
    LOG.log(Level.FINE, "Release container: {0}", containerId);
    final Container container = this.containers.removeAndGet(containerId);
    this.resourceManager.releaseAssignedContainer(container.getId());
    updateRuntimeStatus();
  }
642815
def release_filename(self, id_):
        

        entry = self.__entries.get(id_)
        if entry is None:
            raise ValueError("Invalid filename id (%d)" % id_)

        # Decrease reference count and check if the entry has to be removed...
        if entry.dec_ref_count() == 0:
            del self.__entries[id_]
            del self.__id_lut[entry.filename]
547529
def delete(self, id, attid): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.edit(self._base(id), attid)
950003
def remove(self, cluster_id):
        
        cluster = self._storage.pop(cluster_id)
        cluster.cleanup()
52139
def force_delete(self):
        
        self.__force_deleting__ = True

        self.delete()

        self.__force_deleting__ = False