Delete a bucket.

        Does not actually delete the Bucket, just marks it as deleted.
166456
def delete(cls, bucket_id):
        
        bucket = cls.get(bucket_id)
        if not bucket or bucket.deleted:
            return False

        bucket.deleted = True
        return True
1306116
public void removeBucket(String name) throws FileNotFoundException {
        Bucket bucket;
        synchronized (buckets) {
            if (!buckets.containsKey(name)) {
                throw new FileNotFoundException("No such bucket: "+ name);
            }
            bucket = buckets.remove(name);
        }
        CAPIServer capi = bucket.getCAPIServer();
        if (capi != null) {
            capi.shutdown();
        }
        BucketAdminServer adminServer = bucket.getAdminServer();
        if (adminServer != null) {
            adminServer.shutdown();
        }
        bucket.stop();
    }
1284990
function(bucket, callback) {
    deleteObjects(bucket, function(err, data) {
      if (err) callback(err);
      deleteBucket(bucket, callback);
    });
  }
77438
def clean(self):
        ''''''

        for e in self.bucket.list(self.prefix):
            path = e.name.replace(self.prefix, '', 1).strip('/')
            if path.startswith('_'):
                continue

            self.remove(path)
1130286
def force_delete(self):
        
        self._force_deleting = True

        self.delete()

        self._force_deleting = False
225665
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_website(options)
      resp.data
    end
92918
private void removeBucket(String name)
    {
        try
        {
            if (clusterManager.removeBucket(name))
            {
                LOGGER.info("Bucket [" + name + "] is removed!");
            }
            else
            {
                LOGGER.error("Not able to remove bucket [" + name + "].");
                throw new KunderaException("Not able to remove bucket [" + name + "].");
            }
        }
        catch (CouchbaseException ex)
        {
            LOGGER.error("Not able to remove bucket [" + name + "].", ex);
            throw new KunderaException("Not able to remove bucket [" + name + "].", ex);
        }
    }
22039
def delete(self, bucket=None, ignore=False):
        

        # Make lists
        buckets = bucket
        if isinstance(bucket, six.string_types):
            buckets = [bucket]
        elif bucket is None:
            buckets = reversed(self.buckets)

        # Iterate
        tables = []
        for bucket in buckets:

            # Check existent
            if bucket not in self.buckets:
                if not ignore:
                    message = 'Bucket "%s" doesn\'t exist.' % bucket
                    raise tableschema.exceptions.StorageError(message)
                return

            # Remove from buckets
            if bucket in self.__descriptors:
                del self.__descriptors[bucket]

            # Add table to tables
            table = self.__get_table(bucket)
            tables.append(table)

        # Drop tables, update metadata
        self.__metadata.drop_all(tables=tables)
        self.__metadata.clear()
        self.__reflect()
551586
def delete(self, container, del_objects=False):
        
        return self._manager.delete(container, del_objects=del_objects)
458465
def delete(self):
        

        directory = self._directory()
        assert isinstance(directory, Directory)

        realPath = self.realPath
        assert (os.path.exists(realPath))
        os.remove(realPath)

        directory._fileDeleted(self)
484201
def delete(self):
        

        if not self.object_id:
            return False

        url = self.build_url(
            self._endpoints.get('item').format(id=self.object_id))

        response = self.con.delete(url)
        if not response:
            return False

        self.object_id = None

        return True
116114
def clear_bucket_props(self, bucket):
        
        if not self.pb_clear_bucket_props():
            return False
        msg_code = riak.pb.messages.MSG_CODE_RESET_BUCKET_REQ
        codec = self._get_codec(msg_code)
        msg = codec.encode_clear_bucket_props(bucket)
        self._request(msg, codec)
        return True
608424
def remove_bucket(self, instance, bucket_name):
        
        url = '/buckets/{}/{}'.format(instance, bucket_name)
        self._client.delete_proto(url)
334343
def delete(self):
        
        resp = self._client.delete(type(self).api_endpoint, model=self)

        if 'error' in resp:
            return False
        self.invalidate()
        return True
1201238
public synchronized void invalidateBucket(String bucket) {
    PrefixKey key = new PrefixKey(bucket, "");

    getPrefixSubMap(itemMap, key).clear();
    getPrefixSubMap(prefixMap, key).clear();
  }
26383
public boolean deleteDefaultBucketAcl(String bucketName) {
    // [START deleteDefaultBucketAcl]
    boolean deleted = storage.deleteDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
    if (deleted) {
      // the acl entry was deleted
    } else {
      // the acl entry was not found
    }
    // [END deleteDefaultBucketAcl]
    return deleted;
  }
161162
def remove_object(self, bucket_name, object_name):
        
        is_valid_bucket_name(bucket_name)
        is_non_empty_string(object_name)

        # No reason to store successful response, for errors
        # relevant exceptions are thrown.
        self._url_open('DELETE', bucket_name=bucket_name,
                       object_name=object_name)