struct ColdMetadata {
    headers: HeaderMap,
    origin_etag: Option<HeaderValue>,
    origin_last_modified: Option<HeaderValue>,
}

async fn read_cold_metadata(storage_key: &Key, entry: &ColdEntry) -> Option<ColdMetadata> {
    let bytes = tokio::fs::read(&entry.meta_path).await.ok()?;
    let file: ColdFile = serde_json::from_slice(&bytes).ok()?;
    let key = parse_key_hex(&file.key)?;
    let base_key = parse_key_hex(&file.base_key)?;
    let body_sha256 = parse_key_hex(&file.body_sha256)?;
    let mut vary = file.vary.clone();
    vary.sort();
    vary.dedup();
    let authority = if file.authority.is_empty() {
        file.domain.as_str()
    } else {
        file.authority.as_str()
    };
    let target = if file.target.is_empty() {
        file.path.as_str()
    } else {
        file.target.as_str()
    };
    if file.format != COLD_FORMAT_VERSION
        || key != *storage_key
        || base_key != entry.base_key
        || vary != entry.vary
        || file.revision != entry.revision
        || file.scope != entry.scope
        || file.scheme != entry.scheme
        || authority != entry.authority
        || file.domain != entry.domain
        || file.path != entry.path
        || target != entry.target
        || file.tags != entry.tags
        || file.body_bytes != entry.body_bytes
        || body_sha256 != entry.body_sha256
        || file.ttl != entry.ttl
        || file.stale_while_revalidate != entry.stale_while_revalidate
        || file.stale_if_error != entry.stale_if_error
        || file.must_revalidate != entry.must_revalidate
        || file.proxy_revalidate != entry.proxy_revalidate
        || file.transformed != entry.transformed
        || file.skip_compression != entry.skip_compression
        || file.requires_revalidation != entry.requires_revalidation
        || entry.body_path.file_name().and_then(|name| name.to_str()) != Some(file.body_file.as_str())
    {
        return None;
    }
    let headers = pairs_to_headers(&file.headers)?;
    let origin_etag = file
        .origin_etag
        .as_deref()
        .and_then(|value| HeaderValue::from_str(value).ok());
    let origin_last_modified = file
        .origin_last_modified
        .as_deref()
        .and_then(|value| HeaderValue::from_str(value).ok());
    if entry.has_validator != (origin_etag.is_some() || origin_last_modified.is_some()) {
        return None;
    }
    Some(ColdMetadata {
        headers,
        origin_etag,
        origin_last_modified,
    })
}