def delete(self, name, version, _lock=True):
        """Removes a file from the storage.

        Args:
             name: name of the file being deleted.
                 May contain slashes that are treated as path separators.
             version: file "version" that is meant to be deleted
                 If the file that is stored has newer version than provided,
                 it will not be deleted.
             lock: whether or not to acquire locks
                 This is for internal use only,
                 normal users should always leave it set to True.
        Returns whether or not the file has been deleted.
        """
        link_path = self._link_path(name)
        if _lock:
            file_lock = _exclusive_lock(self._lock_path('links', name))
        else:
            file_lock = _no_lock()
        with file_lock:
            logger.debug('Acquired or inherited lock for link %s.', name)
            if not _path_exists(link_path):
                raise FiletrackerFileNotFoundError
            if _file_version(link_path) > version:
                logger.info(
                    'Tried to delete newer version of %s (%d < %d), ignoring.',
                    name,
                    version,
                    _file_version(link_path),
                )
                return False

            digest = self._digest_for_link(name)

            with _exclusive_lock(self._lock_path('blobs', digest)):
                logger.debug('Acquired lock for blob %s.', digest)
                should_delete_blob = False

                with self._db_transaction() as txn:
                    logger.debug('Started DB transaction (deleting link).')
                    digest_bytes = digest.encode()
                    link_count = self.db.get(digest_bytes, txn=txn)
                    if link_count is None:
                        raise RuntimeError("File exists but has no key in db")

                    link_count = int(link_count)
                    if link_count == 1:
                        logger.debug('Deleting last link to blob %s.', digest)
                        self.db.delete(digest_bytes, txn=txn)
                        self.db.delete(
                            '{}:logical_size'.format(digest).encode(), txn=txn
                        )
                        should_delete_blob = True
                    else:
                        new_count = str(link_count - 1).encode()
                        self.db.put(digest_bytes, new_count, txn=txn)
                    logger.debug('Committing DB transaction (deleting link).')

                logger.debug('Committed DB transaction (deleting link).')

                os.unlink(link_path)
                logger.debug('Deleted link %s.', name)
                if should_delete_blob:
                    os.unlink(self._blob_path(digest))

            logger.debug('Released lock for blob %s.', digest)

        logger.debug('Released (or gave back) lock for link %s.', name)
        return True