Deletes the cluster from memory.

        :param cluster: cluster to delete
        :type cluster: :py:class:`elasticluster.cluster.Cluster`
482971
def delete(self, cluster):
        
        if cluster.name not in self.clusters:
            raise ClusterNotFound(
                "Unable to delete non-existent cluster %s" % cluster.name)
        del self.clusters[cluster.name]
720036
def do_stop_cluster(self, cluster):
        
        try:
            cluster = api.get_cluster(cluster)
            cluster.stop()
            print("Stopping Cluster")
        except ApiException:
            print("Cluster not found")
            return None
108627
def on_cluster_remove(self, name):
        
        discovery_name = self.configurables[Cluster][name].discovery
        if discovery_name in self.configurables[Discovery]:
            self.configurables[Discovery][discovery_name].stop_watching(
                self.configurables[Cluster][name]
            )
            self.kill_thread(name)

        self.sync_balancer_files()
932154
def delete(self, digest):
        
        return self.conn.client.blob_del(self.container_name, digest)
573261
def teardown(self):
        ''''''

        self.device_group.teardown()
        self.trust_domain.teardown()
        self.cluster = None
117148
def delete_host_template(resource_root, name, cluster_name):
  
  return call(resource_root.delete,
      HOST_TEMPLATE_PATH % (cluster_name, name),
      ApiHostTemplate, api_version=3)
987696
def delete(self):
        
        if not self._created:
            return
        try:
            node1 = self._nodes[0]["node"]
            adapter_number1 = self._nodes[0]["adapter_number"]
            port_number1 = self._nodes[0]["port_number"]
        except IndexError:
            return
        try:
            yield from node1.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1), timeout=120)
        # If the node is already delete (user selected multiple element and delete all in the same time)
        except aiohttp.web.HTTPNotFound:
            pass

        try:
            node2 = self._nodes[1]["node"]
            adapter_number2 = self._nodes[1]["adapter_number"]
            port_number2 = self._nodes[1]["port_number"]
        except IndexError:
            return
        try:
            yield from node2.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2), timeout=120)
        # If the node is already delete (user selected multiple element and delete all in the same time)
        except aiohttp.web.HTTPNotFound:
            pass
        yield from super().delete()
955992
def delete(self, callback=None, errback=None):
        
        return self._rest.delete(self.id, callback=callback, errback=errback)
1148691
def delete(options = {})
      options = options.merge(db_cluster_snapshot_identifier: @snapshot_id)
      resp = @client.delete_db_cluster_snapshot(options)
      DBClusterSnapshot.new(
        cluster_id: resp.data.db_cluster_snapshot.db_cluster_identifier,
        snapshot_id: resp.data.db_cluster_snapshot.db_cluster_snapshot_identifier,
        data: resp.data.db_cluster_snapshot,
        client: @client
      )
    end
490368
def delete(self, name, provider='AwsEKS'):
        
        # if self.check_cluster_exists(name) is False:
        #     raise JhubctlError("Cluster name not found in availabe clusters.")

        # Create cluster object
        Cluster = getattr(providers, provider)
        cluster = Cluster(name)
        cluster.delete()

        # Remove from kubeconf
        self.kubeconf.open()
        self.kubeconf.remove_context(name)
        self.kubeconf.remove_user(name)
        self.kubeconf.remove_cluster(cluster.cluster_name)
        self.kubeconf.close()
680989
def delete(self, index=None):
        
        if index is None:
            javabridge.call(self.jobject, "delete", "()V")
        else:
            javabridge.call(self.jobject, "delete", "(I)V", index)
435871
def _clean_cluster(list_c):
    
    global REMOVED
    init = len(list_c)
    list_c = {k: v for k, v in list_c.iteritems() if len(_get_seqs(v)) > parameters.min_seqs}
    logger.debug("_clean_cluster: number of clusters %s " % len(list_c.keys()))
    list_c = {k: _select_loci(v) for k, v in list_c.iteritems()}
    end = len(list_c)
    REMOVED += init - end
    return list_c
450185
def delete(self):
        
        session = self._session
        url = session._build_url(self._resource_path(), self.id)
        return session.delete(url, CB.boolean(204))
1344502
def delete(self):
    
    if self.exists():
      try:
        self._api.objects_delete(self._bucket, self._key)
      except Exception as e:
        raise e
188420
def delete(name, wait=False, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    try:
        conn.delete_cache_cluster(name)
        if not wait:
            log.info('Deleted cache cluster %s.', name)
            return True
        while True:
            config = get_config(name, region, key, keyid, profile)
            if not config:
                return True
            if config['cache_cluster_status'] == 'deleting':
                return True
            time.sleep(2)
        log.info('Deleted cache cluster %s.', name)
        return True
    except boto.exception.BotoServerError as e:
        msg = 'Failed to delete cache cluster {0}.'.format(name)
        log.error(msg)
        log.debug(e)
        return False
1006323
def cleanup(self, cluster):
        
        if self._storage_path and os.path.exists(self._storage_path):
            fname = '%s.%s' % (AnsibleSetupProvider.inventory_file_ending,
                               cluster.name)
            inventory_path = os.path.join(self._storage_path, fname)

            if os.path.exists(inventory_path):
                try:
                    os.unlink(inventory_path)
                    if self._storage_path_tmp:
                        if len(os.listdir(self._storage_path)) == 0:
                            shutil.rmtree(self._storage_path)
                except OSError as ex:
                    log.warning(
                        "AnsibileProvider: Ignoring error while deleting "
                        "inventory file %s: %s", inventory_path, ex)
728969
void deleteUserIndexForClusters(int userIndex) {
		assert (m_clusterIndices.get(userIndex) != null);
		m_clusterIndices.set(userIndex, null);
	}