Delete a RAID configuration on this server.

    :returns: the current RAID configuration after deleting all
        the logical disks.
424464
def delete_configuration():
    
    server = objects.Server()

    select_controllers = lambda x: not x.properties.get('HBA Mode Enabled',
                                                        False)
    _select_controllers_by(server, select_controllers, 'RAID enabled')

    for controller in server.controllers:
        # Trigger delete only if there is some RAID array, otherwise
        # hpssacli/ssacli will fail saying "no logical drives found.".
        if controller.raid_arrays:
            controller.delete_all_logical_drives()
    return get_configuration()
951321
def delete(self):
        
        self.__dmlquery__(self.__class__, self,
                          batch=self._batch,
                          timestamp=self._timestamp,
                          consistency=self.__consistency__,
                          timeout=self._timeout,
                          conditional=self._conditional,
                          if_exists=self._if_exists).delete()
516286
def delete(self, directory_updated=False):
        # pylint: disable=W0212
        
        with self.__lock:
            if self.__deleted:
                # Nothing to do
                return

            # Update status
            self.__deleted = True

            # Notify ConfigurationAdmin, notify services only if the
            # configuration had been updated before
            self.__config_admin._delete(self, self.__updated, directory_updated)

            # Remove the file
            self.__persistence.delete(self.__pid)

            # Clean up
            if self.__properties:
                self.__properties.clear()

            self.__persistence = None
            self.__pid = None
226581
def delete(self, commit=True):
        

        db.session.delete(self)
        return commit and db.session.commit()
570481
def delete(self):
        
        self.__dmlquery__(self.__class__, self,
                          batch=self._batch,
                          timestamp=self._timestamp,
                          consistency=self.__consistency__,
                          timeout=self._timeout).delete()
558340
def _delete_file(configurator, path):
    
    path = os.path.join(configurator.target_directory, path)
    os.remove(path)
    try:
        os.removedirs(os.path.dirname(path))
    except OSError:
        pass
902892
def delete_partition(self, partition_spec, if_exists=False, async_=False, **kw):
        
        async_ = kw.get('async', async_)
        return self.partitions.delete(partition_spec, if_exists=if_exists, async_=async_)
671052
def delete(self):
        
        if self.fullname != "":
            try:
                os.remove(self.fullname)
            except IOError:
                print("Cant delete ",self.fullname)
516219
def clear():
    
    utils.check_for_local_server()
    click.confirm(
        "Are you sure you want to do this? It will delete all of your data",
        abort=True
    )
    server = Server(config["local_server"]["url"])
    for db_name in all_dbs:
        del server[db_name]
1143957
def remove(self, delete=True):
        
        if self.state >= library.MachineState.running:
            session = virtualbox.Session()
            self.lock_machine(session, library.LockType.shared)
            try:
                progress = session.console.power_down()
                progress.wait_for_completion(-1)
            except Exception:
                print("Error powering off machine", file=sys.stderr)
            session.unlock_machine()
            time.sleep(0.5)  # TODO figure out how to ensure session is really unlocked...

        settings_dir = os.path.dirname(self.settings_file_path)
        if delete:
            option = library.CleanupMode.detach_all_return_hard_disks_only
        else:
            option = library.CleanupMode.detach_all_return_none
        media = self.unregister(option)
        if delete:
            progress = self.delete_config(media)
            progress.wait_for_completion(-1)
            media = []

        # if delete - At some point in time virtualbox didn't do a full cleanup
        #             of this dir. Let's double check it has been cleaned up.
        if delete and os.path.exists(settings_dir):
            shutil.rmtree(settings_dir)

        return media
663611
def delete_website_configuration(self, headers=None):
        
        response = self.connection.make_request('DELETE', self.name,
                query_args='website', headers=headers)
        body = response.read()
        boto.log.debug(body)
        if response.status == 204:
            return True
        else:
            raise self.connection.provider.storage_response_error(
                response.status, response.reason, body)
419591
def delete(self):
        
        redis_search_key = ":".join([self.namespace, self.key, "*"])
        keys = self.conn.keys(redis_search_key)
        if keys:
            for key in keys:
                part = key.split(":")[-1]
                self._data.pop(part)
                self.conn.delete(part)

        del self
874561
def delete(self):
        # type: (_BaseResumeManager) -> None
        
        self.close()
        if self._resume_file.exists():  # noqa
            try:
                self._resume_file.unlink()
            except OSError as e:
                logger.warning('could not unlink resume db: {}'.format(e))
        for ext in ('.bak', '.dat', '.dir'):  # noqa
            fp = pathlib.Path(str(self._resume_file) + ext)
            if fp.exists():
                try:
                    fp.unlink()
                except OSError as e:
                    logger.warning('could not unlink resume db: {}'.format(e))
817084
def delete(self):
        
        _, r = self.machine.datacenter.request('DELETE', self.path)
        r.raise_for_status()
957833
def delete(self):
        
        result = yield gen.Task(RedisSession._redis_client.delete, self._key)
        LOGGER.debug('Deleted session %s (%r)', self.id, result)
        self.clear()
        raise gen.Return(result)
972326
def delete(self):
        

        return self._client._delete(
            self.__class__.base_url(
                self.sys['space'].id,
                self.sys['id'],
                environment_id=self._environment_id
            )
        )
573050
def clear(self):
        
        with self._lock:
            self._config = {
                CacheConfig.Morlist: {'last': defaultdict(float), 'intl': {}},
                CacheConfig.Metadata: {'last': defaultdict(float), 'intl': {}},
            }