diff --git a/swh/loader/package/archive/loader.py b/swh/loader/package/archive/loader.py
index 140bf41..7e80cae 100644
--- a/swh/loader/package/archive/loader.py
+++ b/swh/loader/package/archive/loader.py
@@ -1,162 +1,166 @@
 # Copyright (C) 2019-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 import hashlib
 import logging
 from os import path
 import string
 from typing import Any, Dict, Iterator, Mapping, Optional, Sequence, Tuple, Union
 
 import attr
 import iso8601
 
 from swh.loader.package.loader import BasePackageInfo, PackageLoader, PartialExtID
 from swh.loader.package.utils import EMPTY_AUTHOR, release_name
 from swh.model.model import ObjectType, Release, Sha1Git, TimestampWithTimezone
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 
 
 @attr.s
 class ArchivePackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
     length = attr.ib(type=int)
     """Size of the archive file"""
     time = attr.ib(type=Union[str, datetime.datetime])
     """Timestamp of the archive file on the server"""
 
     # default format for gnu
     MANIFEST_FORMAT = string.Template("$time $length $version $url")
 
     def extid(self, manifest_format: Optional[string.Template] = None) -> PartialExtID:
         """Returns a unique intrinsic identifier of this package info
 
         ``manifest_format`` allows overriding the class' default MANIFEST_FORMAT"""
         manifest_format = manifest_format or self.MANIFEST_FORMAT
         # TODO: use parsed attributes instead of self.raw_info
         manifest = manifest_format.substitute(
             {k: str(v) for (k, v) in self.raw_info.items()}
         )
-        return (self.EXTID_TYPE, hashlib.sha256(manifest.encode()).digest())
+        return (
+            self.EXTID_TYPE,
+            self.EXTID_VERSION,
+            hashlib.sha256(manifest.encode()).digest(),
+        )
 
     @classmethod
     def from_metadata(cls, a_metadata: Dict[str, Any]) -> "ArchivePackageInfo":
         url = a_metadata["url"]
         filename = a_metadata.get("filename")
         return cls(
             url=url,
             filename=filename if filename else path.split(url)[-1],
             raw_info=a_metadata,
             length=a_metadata["length"],
             time=a_metadata["time"],
             version=a_metadata["version"],
         )
 
 
 class ArchiveLoader(PackageLoader[ArchivePackageInfo]):
     """Load archive origin's artifact files into swh archive
 
     """
 
     visit_type = "tar"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         artifacts: Sequence[Dict[str, Any]],
         extid_manifest_format: Optional[str] = None,
         max_content_size: Optional[int] = None,
         snapshot_append: bool = False,
     ):
         f"""Loader constructor.
 
         For now, this is the lister's task output.
 
         Args:
             url: Origin url
             artifacts: List of artifact information with keys:
 
                - **time**: last modification time as either isoformat date
                  string or timestamp
 
                - **url**: the artifact url to retrieve filename
 
                - **filename**: optionally, the file's name
 
                - **version**: artifact's version
 
                - **length**: artifact's length
 
             extid_manifest_format: template string used to format a manifest,
                 which is hashed to get the extid of a package.
                 Defaults to {ArchivePackageInfo.MANIFEST_FORMAT!r}
             snapshot_append: if :const:`True`, append latest snapshot content to
                 the new snapshot created by the loader
 
         """
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.artifacts = artifacts  # assume order is enforced in the lister
         self.extid_manifest_format = (
             None
             if extid_manifest_format is None
             else string.Template(extid_manifest_format)
         )
         self.snapshot_append = snapshot_append
 
     def get_versions(self) -> Sequence[str]:
         versions = []
         for archive in self.artifacts:
             v = archive.get("version")
             if v:
                 versions.append(v)
         return versions
 
     def get_default_version(self) -> str:
         # It's the most recent, so for this loader, it's the last one
         return self.artifacts[-1]["version"]
 
     def get_package_info(
         self, version: str
     ) -> Iterator[Tuple[str, ArchivePackageInfo]]:
         for a_metadata in self.artifacts:
             p_info = ArchivePackageInfo.from_metadata(a_metadata)
             if version == p_info.version:
                 # FIXME: this code assumes we have only 1 artifact per
                 # versioned package
                 yield release_name(version), p_info
 
     def new_packageinfo_to_extid(
         self, p_info: ArchivePackageInfo
     ) -> Optional[PartialExtID]:
         return p_info.extid(manifest_format=self.extid_manifest_format)
 
     def build_release(
         self, p_info: ArchivePackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         time = p_info.time  # assume it's a timestamp
         if isinstance(time, str):  # otherwise, assume it's a parsable date
             parsed_time = iso8601.parse_date(time)
         else:
             parsed_time = time
         normalized_time = TimestampWithTimezone.from_datetime(parsed_time)
         msg = f"Synthetic release for archive at {p_info.url}\n"
         return Release(
             name=p_info.version.encode(),
             message=msg.encode(),
             date=normalized_time,
             author=EMPTY_AUTHOR,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         if not self.snapshot_append:
             return {}
         last_snapshot = self.last_snapshot()
         return last_snapshot.to_dict()["branches"] if last_snapshot else {}
diff --git a/swh/loader/package/archive/tests/test_archive.py b/swh/loader/package/archive/tests/test_archive.py
index b195a9b..9549a20 100644
--- a/swh/loader/package/archive/tests/test_archive.py
+++ b/swh/loader/package/archive/tests/test_archive.py
@@ -1,490 +1,491 @@
 # Copyright (C) 2019-2021 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import hashlib
 from io import BytesIO
 from pathlib import Path
 import string
 
 import attr
 import pytest
 from requests.exceptions import ContentDecodingError
 
 from swh.loader.package.archive.loader import ArchiveLoader, ArchivePackageInfo
 from swh.loader.tests import assert_last_visit_matches, check_snapshot, get_stats
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import (
     ObjectType,
     Person,
     Release,
     Snapshot,
     SnapshotBranch,
     TargetType,
     Timestamp,
     TimestampWithTimezone,
 )
 
 URL = "https://ftp.gnu.org/gnu/8sync/"
 GNU_ARTIFACTS = [
     {
         "time": 944729610,
         "url": "https://ftp.gnu.org/gnu/8sync/8sync-0.1.0.tar.gz",
         "length": 221837,
         "filename": "8sync-0.1.0.tar.gz",
         "version": "0.1.0",
     },
     {
         "time": 1480991830,
         "url": "https://ftp.gnu.org/gnu/8sync/8sync-0.2.0.tar.gz",
         "length": 238466,
         "filename": "8sync-0.2.0.tar.gz",
         "version": "0.2.0",
     },
 ]
 
 _expected_new_contents_first_visit = [
     "e9258d81faf5881a2f96a77ba609396f82cb97ad",
     "1170cf105b04b7e2822a0e09d2acf71da7b9a130",
     "fbd27c3f41f2668624ffc80b7ba5db9b92ff27ac",
     "0057bec9b5422aff9256af240b177ac0e3ac2608",
     "2b8d0d0b43a1078fc708930c8ddc2956a86c566e",
     "27de3b3bc6545d2a797aeeb4657c0e215a0c2e55",
     "2e6db43f5cd764e677f416ff0d0c78c7a82ef19b",
     "ae9be03bd2a06ed8f4f118d3fe76330bb1d77f62",
     "edeb33282b2bffa0e608e9d2fd960fd08093c0ea",
     "d64e64d4c73679323f8d4cde2643331ba6c20af9",
     "7a756602914be889c0a2d3952c710144b3e64cb0",
     "84fb589b554fcb7f32b806951dcf19518d67b08f",
     "8624bcdae55baeef00cd11d5dfcfa60f68710a02",
     "e08441aeab02704cfbd435d6445f7c072f8f524e",
     "f67935bc3a83a67259cda4b2d43373bd56703844",
     "809788434b433eb2e3cfabd5d591c9a659d5e3d8",
     "7d7c6c8c5ebaeff879f61f37083a3854184f6c41",
     "b99fec102eb24bffd53ab61fc30d59e810f116a2",
     "7d149b28eaa228b3871c91f0d5a95a2fa7cb0c68",
     "f0c97052e567948adf03e641301e9983c478ccff",
     "7fb724242e2b62b85ca64190c31dcae5303e19b3",
     "4f9709e64a9134fe8aefb36fd827b84d8b617ab5",
     "7350628ccf194c2c3afba4ac588c33e3f3ac778d",
     "0bb892d9391aa706dc2c3b1906567df43cbe06a2",
     "49d4c0ce1a16601f1e265d446b6c5ea6b512f27c",
     "6b5cc594ac466351450f7f64a0b79fdaf4435ad3",
     "3046e5d1f70297e2a507b98224b6222c9688d610",
     "1572607d456d7f633bc6065a2b3048496d679a31",
 ]
 
 _expected_new_directories_first_visit = [
     "daabc65ec75d487b1335ffc101c0ac11c803f8fc",
     "263be23b4a8101d3ad0d9831319a3e0f2b065f36",
     "7f6e63ba6eb3e2236f65892cd822041f1a01dd5c",
     "4db0a3ecbc976083e2dac01a62f93729698429a3",
     "dfef1c80e1098dd5deda664bb44a9ab1f738af13",
     "eca971d346ea54d95a6e19d5051f900237fafdaa",
     "3aebc29ed1fccc4a6f2f2010fb8e57882406b528",
 ]
 
 _expected_new_releases_first_visit = {
     "c92b2ad9e70ef1dce455e8fe1d8e41b92512cc08": (
         "3aebc29ed1fccc4a6f2f2010fb8e57882406b528"
     )
 }
 
 
 def test_archive_visit_with_no_artifact_found(swh_storage, requests_mock_datadir):
     url = URL
     unknown_artifact_url = "https://ftp.g.o/unknown/8sync-0.1.0.tar.gz"
     loader = ArchiveLoader(
         swh_storage,
         url,
         artifacts=[
             {
                 "time": 944729610,
                 "url": unknown_artifact_url,  # unknown artifact
                 "length": 221837,
                 "filename": "8sync-0.1.0.tar.gz",
                 "version": "0.1.0",
             }
         ],
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "uneventful"
     assert actual_load_status["snapshot_id"] is not None
     stats = get_stats(swh_storage)
 
     assert {
         "content": 0,
         "directory": 0,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     assert_last_visit_matches(swh_storage, url, status="partial", type="tar")
 
 
 def test_archive_visit_with_release_artifact_no_prior_visit(
     swh_storage, requests_mock_datadir
 ):
     """With no prior visit, load a gnu project ends up with 1 snapshot
 
     """
     loader = ArchiveLoader(swh_storage, URL, artifacts=GNU_ARTIFACTS[:1])
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
 
     expected_snapshot_first_visit_id = hash_to_bytes(
         "9efecc835e8f99254934f256b5301b94f348fd17"
     )
 
     assert actual_load_status["snapshot_id"] == hash_to_hex(
         expected_snapshot_first_visit_id
     )
 
     assert_last_visit_matches(swh_storage, URL, status="full", type="tar")
 
     stats = get_stats(swh_storage)
     assert {
         "content": len(_expected_new_contents_first_visit),
         "directory": len(_expected_new_directories_first_visit),
         "origin": 1,
         "origin_visit": 1,
         "release": len(_expected_new_releases_first_visit),
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     release_id = hash_to_bytes(list(_expected_new_releases_first_visit)[0])
     expected_snapshot = Snapshot(
         id=expected_snapshot_first_visit_id,
         branches={
             b"HEAD": SnapshotBranch(
                 target_type=TargetType.ALIAS, target=b"releases/0.1.0",
             ),
             b"releases/0.1.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=release_id,
             ),
         },
     )
     check_snapshot(expected_snapshot, swh_storage)
 
     assert swh_storage.release_get([release_id])[0] == Release(
         id=release_id,
         name=b"0.1.0",
         message=(
             b"Synthetic release for archive at "
             b"https://ftp.gnu.org/gnu/8sync/8sync-0.1.0.tar.gz\n"
         ),
         target=hash_to_bytes("3aebc29ed1fccc4a6f2f2010fb8e57882406b528"),
         target_type=ObjectType.DIRECTORY,
         synthetic=True,
         author=Person.from_fullname(b""),
         date=TimestampWithTimezone(
             timestamp=Timestamp(seconds=944729610, microseconds=0),
             offset=0,
             negative_utc=False,
         ),
     )
 
     expected_contents = map(hash_to_bytes, _expected_new_contents_first_visit)
     assert list(swh_storage.content_missing_per_sha1(expected_contents)) == []
 
     expected_dirs = map(hash_to_bytes, _expected_new_directories_first_visit)
     assert list(swh_storage.directory_missing(expected_dirs)) == []
 
     expected_rels = map(hash_to_bytes, _expected_new_releases_first_visit)
     assert list(swh_storage.release_missing(expected_rels)) == []
 
 
 def test_archive_2_visits_without_change(swh_storage, requests_mock_datadir):
     """With no prior visit, load a gnu project ends up with 1 snapshot
 
     """
     url = URL
     loader = ArchiveLoader(swh_storage, url, artifacts=GNU_ARTIFACTS[:1])
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
 
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     actual_load_status2 = loader.load()
     assert actual_load_status2["status"] == "uneventful"
     assert actual_load_status2["snapshot_id"] is not None
     assert actual_load_status["snapshot_id"] == actual_load_status2["snapshot_id"]
 
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith("https://ftp.gnu.org")
     ]
     assert len(urls) == 1
 
 
 def test_archive_2_visits_with_new_artifact(swh_storage, requests_mock_datadir):
     """With no prior visit, load a gnu project ends up with 1 snapshot
 
     """
     url = URL
     artifact1 = GNU_ARTIFACTS[0]
     loader = ArchiveLoader(swh_storage, url, [artifact1])
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
 
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     stats = get_stats(swh_storage)
     assert {
         "content": len(_expected_new_contents_first_visit),
         "directory": len(_expected_new_directories_first_visit),
         "origin": 1,
         "origin_visit": 1,
         "release": len(_expected_new_releases_first_visit),
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith("https://ftp.gnu.org")
     ]
     assert len(urls) == 1
 
     artifact2 = GNU_ARTIFACTS[1]
 
     loader2 = ArchiveLoader(swh_storage, url, [artifact1, artifact2])
     stats2 = get_stats(swh_storage)
     assert stats == stats2  # ensure we share the storage
 
     actual_load_status2 = loader2.load()
     assert actual_load_status2["status"] == "eventful"
     assert actual_load_status2["snapshot_id"] is not None
 
     stats2 = get_stats(swh_storage)
     assert {
         "content": len(_expected_new_contents_first_visit) + 14,
         "directory": len(_expected_new_directories_first_visit) + 8,
         "origin": 1,
         "origin_visit": 1 + 1,
         "release": len(_expected_new_releases_first_visit) + 1,
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1 + 1,
     } == stats2
 
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith("https://ftp.gnu.org")
     ]
     # 1 artifact (2nd time no modification) + 1 new artifact
     assert len(urls) == 2
 
 
 def test_archive_2_visits_without_change_not_gnu(swh_storage, requests_mock_datadir):
     """Load a project archive (not gnu) ends up with 1 snapshot
 
     """
     url = "https://something.else.org/8sync/"
     artifacts = [  # this is not a gnu artifact
         {
             "time": "1999-12-09T09:53:30+00:00",  # it's also not a timestamp
             "sha256": "d5d1051e59b2be6f065a9fc6aedd3a391e44d0274b78b9bb4e2b57a09134dbe4",  # noqa
             # keep a gnu artifact reference to avoid adding other test files
             "url": "https://ftp.gnu.org/gnu/8sync/8sync-0.2.0.tar.gz",
             "length": 238466,
             "filename": "8sync-0.2.0.tar.gz",
             "version": "0.2.0",
         }
     ]
 
     # Here the loader defines the id_keys to use for existence in the snapshot
     # It's not the default archive loader which
     loader = ArchiveLoader(
         swh_storage,
         url,
         artifacts=artifacts,
         extid_manifest_format="$sha256 $length $url",
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     actual_load_status2 = loader.load()
     assert actual_load_status2["status"] == "uneventful"
     assert actual_load_status2["snapshot_id"] == actual_load_status["snapshot_id"]
     assert_last_visit_matches(swh_storage, url, status="full", type="tar")
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith("https://ftp.gnu.org")
     ]
     assert len(urls) == 1
 
 
 def test_archive_extid():
     """Compute primary key should return the right identity
 
     """
 
     @attr.s
     class TestPackageInfo(ArchivePackageInfo):
         a = attr.ib()
         b = attr.ib()
 
     metadata = GNU_ARTIFACTS[0]
 
     p_info = TestPackageInfo(
         raw_info={**metadata, "a": 1, "b": 2}, a=1, b=2, **metadata,
     )
 
     for manifest_format, expected_manifest in [
         (string.Template("$a $b"), b"1 2"),
         (string.Template(""), b""),
         (None, "{time} {length} {version} {url}".format(**metadata).encode()),
     ]:
         actual_id = p_info.extid(manifest_format=manifest_format)
         assert actual_id == (
             "package-manifest-sha256",
+            0,
             hashlib.sha256(expected_manifest).digest(),
         )
 
     with pytest.raises(KeyError):
         p_info.extid(manifest_format=string.Template("$a $unknown_key"))
 
 
 def test_archive_snapshot_append(swh_storage, requests_mock_datadir):
     # first loading with a first artifact
     artifact1 = GNU_ARTIFACTS[0]
     loader = ArchiveLoader(swh_storage, URL, [artifact1], snapshot_append=True)
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, URL, status="full", type="tar")
 
     # check expected snapshot
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     branch_artifact1_name = f"releases/{artifact1['version']}".encode()
     assert b"HEAD" in snapshot.branches
     assert branch_artifact1_name in snapshot.branches
     assert snapshot.branches[b"HEAD"].target == branch_artifact1_name
 
     # second loading with a second artifact
     artifact2 = GNU_ARTIFACTS[1]
     loader = ArchiveLoader(swh_storage, URL, [artifact2], snapshot_append=True)
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, URL, status="full", type="tar")
 
     # check expected snapshot, should contain a new branch and the
     # branch for the first artifact
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 3
     branch_artifact2_name = f"releases/{artifact2['version']}".encode()
     assert b"HEAD" in snapshot.branches
     assert branch_artifact2_name in snapshot.branches
     assert branch_artifact1_name in snapshot.branches
     assert snapshot.branches[b"HEAD"].target == branch_artifact2_name
 
 
 def test_archive_snapshot_append_branch_override(swh_storage, requests_mock_datadir):
     # first loading for a first artifact
     artifact1 = GNU_ARTIFACTS[0]
     loader = ArchiveLoader(swh_storage, URL, [artifact1], snapshot_append=True)
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, URL, status="full", type="tar")
 
     # check expected snapshot
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     branch_artifact1_name = f"releases/{artifact1['version']}".encode()
     assert branch_artifact1_name in snapshot.branches
     branch_target_first_visit = snapshot.branches[branch_artifact1_name].target
 
     # second loading for a second artifact with same version as the first one
     # but with different tarball content
     artifact2 = dict(GNU_ARTIFACTS[0])
     artifact2["url"] = GNU_ARTIFACTS[1]["url"]
     artifact2["time"] = GNU_ARTIFACTS[1]["time"]
     artifact2["length"] = GNU_ARTIFACTS[1]["length"]
     loader = ArchiveLoader(swh_storage, URL, [artifact2], snapshot_append=True)
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, URL, status="full", type="tar")
 
     # check expected snapshot, should contain the same branch as previously
     # but with different target
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     assert branch_artifact1_name in snapshot.branches
     branch_target_second_visit = snapshot.branches[branch_artifact1_name].target
 
     assert branch_target_first_visit != branch_target_second_visit
 
 
 @pytest.fixture
 def not_gzipped_tarball_bytes(datadir):
     return Path(datadir, "not_gzipped_tarball.tar.gz").read_bytes()
 
 
 def test_archive_not_gzipped_tarball(
     swh_storage, requests_mock, not_gzipped_tarball_bytes
 ):
     """Check that a tarball erroneously marked as gzip compressed can still
     be downloaded and processed.
 
     """
     filename = "not_gzipped_tarball.tar.gz"
     url = f"https://example.org/ftp/{filename}"
     requests_mock.get(
         url,
         [
             {"exc": ContentDecodingError,},
             {"body": BytesIO(not_gzipped_tarball_bytes),},
         ],
     )
     loader = ArchiveLoader(
         swh_storage,
         url,
         artifacts=[
             {
                 "time": 944729610,
                 "url": url,
                 "length": 221837,
                 "filename": filename,
                 "version": "0.1.0",
             }
         ],
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
 
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     assert b"releases/0.1.0" in snapshot.branches
diff --git a/swh/loader/package/debian/loader.py b/swh/loader/package/debian/loader.py
index f31c0e9..c2b654e 100644
--- a/swh/loader/package/debian/loader.py
+++ b/swh/loader/package/debian/loader.py
@@ -1,474 +1,475 @@
 # Copyright (C) 2017-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import email.utils
 import logging
 from os import path
 import re
 import subprocess
 from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple
 
 import attr
 from dateutil.parser import parse as parse_date
 from debian.changelog import Changelog
 from debian.deb822 import Dsc
 
 from swh.loader.package.loader import BasePackageInfo, PackageLoader, PartialExtID
 from swh.loader.package.utils import download, release_name
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import ObjectType, Person, Release, Sha1Git, TimestampWithTimezone
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 UPLOADERS_SPLIT = re.compile(r"(?<=\>)\s*,\s*")
 
 EXTID_TYPE = "dsc-sha256"
+EXTID_VERSION = 1
 
 
 class DscCountError(ValueError):
     """Raised when an unexpected number of .dsc files is seen"""
 
     pass
 
 
 @attr.s
 class DebianFileMetadata:
     name = attr.ib(type=str)
     """Filename"""
 
     size = attr.ib(type=int)
     uri = attr.ib(type=str)
     """URL of this specific file"""
 
     # all checksums are not always available, make them optional
     sha256 = attr.ib(type=str, default="")
     md5sum = attr.ib(type=str, default="")
     sha1 = attr.ib(type=str, default="")
 
     # Some of the DSC files imported in swh apparently had a Checksums-SHA512
     # field which got recorded in the archive. Current versions of dpkg-source
     # don't seem to generate them, but keep the field available for
     # future-proofing.
     sha512 = attr.ib(type=str, default="")
 
 
 @attr.s
 class DebianPackageChangelog:
     person = attr.ib(type=Dict[str, str])
     """A dict with fields like, model.Person, except they are str instead
     of bytes, and 'email' is optional."""
     date = attr.ib(type=str)
     """Date of the changelog entry."""
     history = attr.ib(type=List[Tuple[str, str]])
     """List of tuples (package_name, version)"""
 
 
 @attr.s
 class DebianPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
     files = attr.ib(type=Dict[str, DebianFileMetadata])
     """Metadata of the files (.deb, .dsc, ...) of the package."""
     name = attr.ib(type=str)
     intrinsic_version = attr.ib(type=str)
     """eg. ``0.7.2-3``, while :attr:`version` would be ``stretch/contrib/0.7.2-3``"""
 
     @classmethod
     def from_metadata(
         cls, a_metadata: Dict[str, Any], url: str, version: str
     ) -> "DebianPackageInfo":
         intrinsic_version = a_metadata["version"]
         assert "/" in version and "/" not in intrinsic_version, (
             version,
             intrinsic_version,
         )
         return cls(
             url=url,
             filename=None,
             version=version,
             raw_info=a_metadata,
             files={
                 file_name: DebianFileMetadata(**file_metadata)
                 for (file_name, file_metadata) in a_metadata.get("files", {}).items()
             },
             name=a_metadata["name"],
             intrinsic_version=intrinsic_version,
         )
 
     def extid(self) -> Optional[PartialExtID]:
         dsc_files = [
             file for (name, file) in self.files.items() if name.endswith(".dsc")
         ]
 
         if len(dsc_files) != 1:
             raise DscCountError(
                 f"Expected exactly one .dsc file for package {self.name}, "
                 f"got {len(dsc_files)}"
             )
 
-        return (EXTID_TYPE, hash_to_bytes(dsc_files[0].sha256))
+        return (EXTID_TYPE, EXTID_VERSION, hash_to_bytes(dsc_files[0].sha256))
 
 
 @attr.s
 class IntrinsicPackageMetadata:
     """Metadata extracted from a package's .dsc file."""
 
     name = attr.ib(type=str)
     version = attr.ib(type=str)
     changelog = attr.ib(type=DebianPackageChangelog)
     maintainers = attr.ib(type=List[Dict[str, str]])
     """A list of dicts with fields like, model.Person, except they are str instead
     of bytes, and 'email' is optional."""
 
 
 class DebianLoader(PackageLoader[DebianPackageInfo]):
     """Load debian origins into swh archive.
 
     """
 
     visit_type = "deb"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         packages: Mapping[str, Any],
         max_content_size: Optional[int] = None,
     ):
         """Debian Loader implementation.
 
         Args:
             url: Origin url (e.g. deb://Debian/packages/cicero)
             date: Ignored
             packages: versioned packages and associated artifacts, example::
 
               {
                 'stretch/contrib/0.7.2-3': {
                   'name': 'cicero',
                   'version': '0.7.2-3'
                   'files': {
                     'cicero_0.7.2-3.diff.gz': {
                        'md5sum': 'a93661b6a48db48d59ba7d26796fc9ce',
                        'name': 'cicero_0.7.2-3.diff.gz',
                        'sha256': 'f039c9642fe15c75bed5254315e2a29f...',
                        'size': 3964,
                        'uri': 'http://d.d.o/cicero_0.7.2-3.diff.gz',
                     },
                     'cicero_0.7.2-3.dsc': {
                       'md5sum': 'd5dac83eb9cfc9bb52a15eb618b4670a',
                       'name': 'cicero_0.7.2-3.dsc',
                       'sha256': '35b7f1048010c67adfd8d70e4961aefb...',
                       'size': 1864,
                       'uri': 'http://d.d.o/cicero_0.7.2-3.dsc',
                     },
                     'cicero_0.7.2.orig.tar.gz': {
                       'md5sum': '4353dede07c5728319ba7f5595a7230a',
                       'name': 'cicero_0.7.2.orig.tar.gz',
                       'sha256': '63f40f2436ea9f67b44e2d4bd669dbab...',
                       'size': 96527,
                       'uri': 'http://d.d.o/cicero_0.7.2.orig.tar.gz',
                     }
                   },
                 },
                 # ...
               }
 
         """
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.packages = packages
 
     def get_versions(self) -> Sequence[str]:
         """Returns the keys of the packages input (e.g.
            stretch/contrib/0.7.2-3, etc...)
 
         """
         return list(self.packages.keys())
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, DebianPackageInfo]]:
         meta = self.packages[version]
         p_info = DebianPackageInfo.from_metadata(meta, url=self.url, version=version)
         yield release_name(version), p_info
 
     def download_package(
         self, p_info: DebianPackageInfo, tmpdir: str
     ) -> List[Tuple[str, Mapping]]:
         """Contrary to other package loaders (1 package, 1 artifact),
         `p_info.files` represents the package's datafiles set to fetch:
         - <package-version>.orig.tar.gz
         - <package-version>.dsc
         - <package-version>.diff.gz
 
         This is delegated to the `download_package` function.
 
         """
         all_hashes = download_package(p_info, tmpdir)
         logger.debug("all_hashes: %s", all_hashes)
         res = []
         for hashes in all_hashes.values():
             res.append((tmpdir, hashes))
             logger.debug("res: %s", res)
         return res
 
     def uncompress(
         self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]], dest: str
     ) -> str:
         logger.debug("dl_artifacts: %s", dl_artifacts)
         return extract_package(dl_artifacts, dest=dest)
 
     def build_release(
         self, p_info: DebianPackageInfo, uncompressed_path: str, directory: Sha1Git,
     ) -> Optional[Release]:
         dsc_url, dsc_name = dsc_information(p_info)
         if not dsc_name:
             raise ValueError("dsc name for url %s should not be None" % dsc_url)
         dsc_path = path.join(path.dirname(uncompressed_path), dsc_name)
         intrinsic_metadata = get_intrinsic_package_metadata(
             p_info, dsc_path, uncompressed_path
         )
 
         logger.debug("intrinsic_metadata: %s", intrinsic_metadata)
         logger.debug("p_info: %s", p_info)
 
         msg = (
             f"Synthetic release for Debian source package {p_info.name} "
             f"version {p_info.intrinsic_version}\n"
         )
 
         author = prepare_person(intrinsic_metadata.changelog.person)
         date = TimestampWithTimezone.from_iso8601(intrinsic_metadata.changelog.date)
 
         # inspired from swh.loader.debian.converters.package_metadata_to_revision
         return Release(
             name=p_info.intrinsic_version.encode(),
             message=msg.encode(),
             author=author,
             date=date,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
 
 
 def uid_to_person(uid: str) -> Dict[str, str]:
     """Convert an uid to a person suitable for insertion.
 
     Args:
         uid: an uid of the form "Name <email@ddress>"
 
     Returns:
         a dictionary with the following keys:
 
         - name: the name associated to the uid
         - email: the mail associated to the uid
         - fullname: the actual uid input
 
     """
     logger.debug("uid: %s", uid)
     ret = {
         "name": "",
         "email": "",
         "fullname": uid,
     }
 
     name, mail = email.utils.parseaddr(uid)
     if name and email:
         ret["name"] = name
         ret["email"] = mail
     else:
         ret["name"] = uid
     return ret
 
 
 def prepare_person(person: Mapping[str, str]) -> Person:
     """Prepare person for swh serialization...
 
     Args:
         A person dict
 
     Returns:
         A person ready for storage
 
     """
     return Person.from_dict(
         {key: value.encode("utf-8") for (key, value) in person.items()}
     )
 
 
 def download_package(p_info: DebianPackageInfo, tmpdir: Any) -> Mapping[str, Any]:
     """Fetch a source package in a temporary directory and check the checksums
     for all files.
 
     Args:
         p_info: Information on a package
         tmpdir: Where to download and extract the files to ingest
 
     Returns:
         Dict of swh hashes per filename key
 
     """
     all_hashes = {}
     for filename, fileinfo in p_info.files.items():
         uri = fileinfo.uri
         logger.debug("fileinfo: %s", fileinfo)
         extrinsic_hashes = {"md5": fileinfo.md5sum}
         if fileinfo.sha256:
             extrinsic_hashes["sha256"] = fileinfo.sha256
         if fileinfo.sha1:
             extrinsic_hashes["sha1"] = fileinfo.sha1
         logger.debug("extrinsic_hashes(%s): %s", filename, extrinsic_hashes)
         _, hashes = download(
             uri, dest=tmpdir, filename=filename, hashes=extrinsic_hashes
         )
         all_hashes[filename] = hashes
 
     logger.debug("all_hashes: %s", all_hashes)
     return all_hashes
 
 
 def dsc_information(p_info: DebianPackageInfo) -> Tuple[Optional[str], Optional[str]]:
     """Retrieve dsc information from a package.
 
     Args:
         p_info: Package metadata information
 
     Returns:
         Tuple of dsc file's uri, dsc's full disk path
 
     """
     dsc_name = None
     dsc_url = None
     for filename, fileinfo in p_info.files.items():
         if filename.endswith(".dsc"):
             if dsc_name:
                 raise DscCountError(
                     "Package %s_%s references several dsc files."
                     % (p_info.name, p_info.intrinsic_version)
                 )
             dsc_url = fileinfo.uri
             dsc_name = filename
 
     return dsc_url, dsc_name
 
 
 def extract_package(dl_artifacts: List[Tuple[str, Mapping]], dest: str) -> str:
     """Extract a Debian source package to a given directory.
 
     Note that after extraction the target directory will be the root of the
     extracted package, rather than containing it.
 
     Args:
         package: package information dictionary
         dest: directory where the package files are stored
 
     Returns:
         Package extraction directory
 
     """
     a_path = dl_artifacts[0][0]
     logger.debug("dl_artifacts: %s", dl_artifacts)
     for _, hashes in dl_artifacts:
         logger.debug("hashes: %s", hashes)
         filename = hashes["filename"]
         if filename.endswith(".dsc"):
             dsc_name = filename
             break
 
     dsc_path = path.join(a_path, dsc_name)
     destdir = path.join(dest, "extracted")
     logfile = path.join(dest, "extract.log")
     logger.debug(
         "extract Debian source package %s in %s" % (dsc_path, destdir),
         extra={"swh_type": "deb_extract", "swh_dsc": dsc_path, "swh_destdir": destdir,},
     )
 
     cmd = [
         "dpkg-source",
         "--no-copy",
         "--no-check",
         "--ignore-bad-version",
         "-x",
         dsc_path,
         destdir,
     ]
 
     try:
         with open(logfile, "w") as stdout:
             subprocess.check_call(cmd, stdout=stdout, stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
         logdata = open(logfile, "r").read()
         raise ValueError(
             "dpkg-source exited with code %s: %s" % (e.returncode, logdata)
         ) from None
 
     return destdir
 
 
 def get_intrinsic_package_metadata(
     p_info: DebianPackageInfo, dsc_path: str, extracted_path: str
 ) -> IntrinsicPackageMetadata:
     """Get the package metadata from the source package at dsc_path,
     extracted in extracted_path.
 
     Args:
         p_info: the package information
         dsc_path: path to the package's dsc file
         extracted_path: the path where the package got extracted
 
     Returns:
         dict: a dictionary with the following keys:
 
         - history: list of (package_name, package_version) tuples parsed from
           the package changelog
 
     """
     with open(dsc_path, "rb") as dsc:
         parsed_dsc = Dsc(dsc)
 
     # Parse the changelog to retrieve the rest of the package information
     changelog_path = path.join(extracted_path, "debian/changelog")
     with open(changelog_path, "rb") as changelog_file:
         try:
             parsed_changelog = Changelog(changelog_file)
         except UnicodeDecodeError:
             logger.warning(
                 "Unknown encoding for changelog %s,"
                 " falling back to iso" % changelog_path,
                 extra={
                     "swh_type": "deb_changelog_encoding",
                     "swh_name": p_info.name,
                     "swh_version": str(p_info.version),
                     "swh_changelog": changelog_path,
                 },
             )
 
             # need to reset as Changelog scrolls to the end of the file
             changelog_file.seek(0)
             parsed_changelog = Changelog(changelog_file, encoding="iso-8859-15")
 
     history: List[Tuple[str, str]] = []
 
     for block in parsed_changelog:
         assert block.package is not None
         history.append((block.package, str(block.version)))
 
     changelog = DebianPackageChangelog(
         person=uid_to_person(parsed_changelog.author),
         date=parse_date(parsed_changelog.date).isoformat(),
         history=history[1:],
     )
 
     maintainers = [
         uid_to_person(parsed_dsc["Maintainer"]),
     ]
     maintainers.extend(
         uid_to_person(person)
         for person in UPLOADERS_SPLIT.split(parsed_dsc.get("Uploaders", ""))
     )
 
     return IntrinsicPackageMetadata(
         name=p_info.name,
         version=str(p_info.intrinsic_version),
         changelog=changelog,
         maintainers=maintainers,
     )
diff --git a/swh/loader/package/loader.py b/swh/loader/package/loader.py
index 2efe900..6b70468 100644
--- a/swh/loader/package/loader.py
+++ b/swh/loader/package/loader.py
@@ -1,1049 +1,1063 @@
 # Copyright (C) 2019-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 import hashlib
 from itertools import islice
 import json
 import logging
 import os
 import string
 import sys
 import tempfile
 from typing import (
     Any,
     Dict,
     Generic,
     Iterable,
     Iterator,
     List,
     Mapping,
     Optional,
     Sequence,
     Set,
     Tuple,
     TypeVar,
 )
 
 import attr
 from requests.exceptions import ContentDecodingError
 import sentry_sdk
 
 from swh.core.tarball import uncompress
 from swh.loader.core.loader import BaseLoader
 from swh.loader.exception import NotFound
 from swh.loader.package.utils import download
 from swh.model import from_disk
 from swh.model.hashutil import hash_to_hex
 from swh.model.model import (
     ExtID,
     MetadataAuthority,
     MetadataAuthorityType,
     MetadataFetcher,
 )
 from swh.model.model import (
     Origin,
     OriginVisit,
     OriginVisitStatus,
     RawExtrinsicMetadata,
     Release,
     Revision,
     Sha1Git,
     Snapshot,
 )
 from swh.model.model import ObjectType as ModelObjectType
 from swh.model.swhids import CoreSWHID, ExtendedObjectType, ExtendedSWHID, ObjectType
 from swh.storage.algos.snapshot import snapshot_get_latest
 from swh.storage.interface import StorageInterface
 from swh.storage.utils import now
 
 logger = logging.getLogger(__name__)
 
 
 SWH_METADATA_AUTHORITY = MetadataAuthority(
     type=MetadataAuthorityType.REGISTRY,
     url="https://softwareheritage.org/",
     metadata={},
 )
 """Metadata authority for extrinsic metadata generated by Software Heritage.
 Used for metadata on "original artifacts", ie. length, filename, and checksums
 of downloaded archive files."""
 
 
-PartialExtID = Tuple[str, bytes]
+PartialExtID = Tuple[str, int, bytes]
 """The ``extid_type`` and ``extid`` fields of an :class:`ExtID` object."""
 
 
 @attr.s
 class RawExtrinsicMetadataCore:
     """Contains the core of the metadata extracted by a loader, that will be
     used to build a full RawExtrinsicMetadata object by adding object identifier,
     context, and provenance information."""
 
     format = attr.ib(type=str)
     metadata = attr.ib(type=bytes)
     discovery_date = attr.ib(type=Optional[datetime.datetime], default=None)
     """Defaults to the visit date."""
 
 
 @attr.s
 class BasePackageInfo:
     """Compute the primary key for a dict using the id_keys as primary key
        composite.
 
     Args:
         d: A dict entry to compute the primary key on
         id_keys: Sequence of keys to use as primary key
 
     Returns:
         The identity for that dict entry
 
     """
 
     url = attr.ib(type=str)
     filename = attr.ib(type=Optional[str])
     version = attr.ib(type=str)
     """Version name/number."""
 
     MANIFEST_FORMAT: Optional[string.Template] = None
     """If not None, used by the default extid() implementation to format a manifest,
     before hashing it to produce an ExtID."""
 
     EXTID_TYPE: str = "package-manifest-sha256"
+    EXTID_VERSION: int = 0
 
     # The following attribute has kw_only=True in order to allow subclasses
     # to add attributes. Without kw_only, attributes without default values cannot
     # go after attributes with default values.
     # See <https://github.com/python-attrs/attrs/issues/38>
 
     directory_extrinsic_metadata = attr.ib(
         type=List[RawExtrinsicMetadataCore], default=[], kw_only=True,
     )
     """:term:`extrinsic metadata` collected by the loader, that will be attached to the
     loaded directory and added to the Metadata storage."""
 
     # TODO: add support for metadata for releases and contents
 
     def extid(self) -> Optional[PartialExtID]:
         """Returns a unique intrinsic identifier of this package info,
         or None if this package info is not 'deduplicatable' (meaning that
         we will always load it, instead of checking the ExtID storage
         to see if we already did)"""
         if self.MANIFEST_FORMAT is None:
             return None
         else:
             manifest = self.MANIFEST_FORMAT.substitute(
                 {k: str(v) for (k, v) in attr.asdict(self).items()}
             )
-            return (self.EXTID_TYPE, hashlib.sha256(manifest.encode()).digest())
+            return (
+                self.EXTID_TYPE,
+                self.EXTID_VERSION,
+                hashlib.sha256(manifest.encode()).digest(),
+            )
 
 
 TPackageInfo = TypeVar("TPackageInfo", bound=BasePackageInfo)
 
 
 class PackageLoader(BaseLoader, Generic[TPackageInfo]):
     # Origin visit type (str) set by the loader
     visit_type = ""
     visit_date: datetime.datetime
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         max_content_size: Optional[int] = None,
     ):
         """Loader's constructor. This raises exception if the minimal required
            configuration is missing (cf. fn:`check` method).
 
         Args:
             storage: Storage instance
             url: Origin url to load data from
 
         """
         super().__init__(storage=storage, max_content_size=max_content_size)
         self.url = url
         self.visit_date = datetime.datetime.now(tz=datetime.timezone.utc)
 
     def get_versions(self) -> Sequence[str]:
         """Return the list of all published package versions.
 
         Raises:
            class:`swh.loader.exception.NotFound` error when failing to read the
             published package versions.
 
         Returns:
             Sequence of published versions
 
         """
         return []
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, TPackageInfo]]:
         """Given a release version of a package, retrieve the associated
            package information for such version.
 
         Args:
             version: Package version
 
         Returns:
             (branch name, package metadata)
 
         """
         yield from {}
 
     def build_release(
         self, p_info: TPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         """Build the release from the archive metadata (extrinsic
         artifact metadata) and the intrinsic metadata.
 
         Args:
             p_info: Package information
             uncompressed_path: Artifact uncompressed path on disk
         """
         raise NotImplementedError("build_release")
 
     def get_default_version(self) -> str:
         """Retrieve the latest release version if any.
 
         Returns:
             Latest version
 
         """
         return ""
 
     def last_snapshot(self) -> Optional[Snapshot]:
         """Retrieve the last snapshot out of the last visit.
 
         """
         return snapshot_get_latest(self.storage, self.url)
 
     def new_packageinfo_to_extid(self, p_info: TPackageInfo) -> Optional[PartialExtID]:
         return p_info.extid()
 
     def _get_known_extids(
         self, packages_info: List[TPackageInfo]
     ) -> Dict[PartialExtID, List[CoreSWHID]]:
         """Compute the ExtIDs from new PackageInfo objects, searches which are already
         loaded in the archive, and returns them if any."""
 
         # Compute the ExtIDs of all the new packages, grouped by extid type
-        new_extids: Dict[str, List[bytes]] = {}
+        new_extids: Dict[Tuple[str, int], List[bytes]] = {}
         for p_info in packages_info:
             res = p_info.extid()
             if res is not None:
-                (extid_type, extid_extid) = res
-                new_extids.setdefault(extid_type, []).append(extid_extid)
+                (extid_type, extid_version, extid_extid) = res
+                new_extids.setdefault((extid_type, extid_version), []).append(
+                    extid_extid
+                )
 
         # For each extid type, call extid_get_from_extid() with all the extids of
         # that type, and store them in the '(type, extid) -> target' map.
         known_extids: Dict[PartialExtID, List[CoreSWHID]] = {}
-        for (extid_type, extids) in new_extids.items():
-            for extid in self.storage.extid_get_from_extid(extid_type, extids):
+        for ((extid_type, extid_version), extids) in new_extids.items():
+            for extid in self.storage.extid_get_from_extid(
+                extid_type, extids, version=extid_version
+            ):
                 if extid is not None:
-                    key = (extid.extid_type, extid.extid)
+                    key = (extid.extid_type, extid_version, extid.extid)
                     known_extids.setdefault(key, []).append(extid.target)
 
         return known_extids
 
     def resolve_object_from_extids(
         self,
         known_extids: Dict[PartialExtID, List[CoreSWHID]],
         p_info: TPackageInfo,
         whitelist: Set[Sha1Git],
     ) -> Optional[CoreSWHID]:
         """Resolve the revision/release from known ExtIDs and a package info object.
 
         If the artifact has already been downloaded, this will return the
         existing release (or revision) targeting that uncompressed artifact directory.
         Otherwise, this returns None.
 
         Args:
             known_extids: Dict built from a list of ExtID, with the target as value
             p_info: Package information
             whitelist: Any ExtID with target not in this set is filtered out
 
         Returns:
             None or release/revision SWHID
 
         """
         new_extid = p_info.extid()
         if new_extid is None:
             return None
 
         extid_targets = set()
         for extid_target in known_extids.get(new_extid, []):
             if extid_target.object_id not in whitelist:
                 # There is a known ExtID for this package, but its target is not
                 # in the snapshot.
                 # This can happen for three reasons:
                 #
                 # 1. a loader crashed after writing the ExtID, but before writing
                 #    the snapshot
                 # 2. some other loader loaded the same artifact, but produced
                 #    a different revision, causing an additional ExtID object
                 #    to be written. We will probably find this loader's ExtID
                 #    in a future iteration of this loop.
                 #    Note that for now, this is impossible, as each loader has a
                 #    completely different extid_type, but this is an implementation
                 #    detail of each loader.
                 # 3. we took a snapshot, then the package disappeared,
                 #    then we took another snapshot, and the package reappeared
                 #
                 # In case of 1, we must actually load the package now,
                 # so let's do it.
                 # TODO: detect when we are in case 3 using release_missing
                 # or revision_missing instead of the snapshot.
                 continue
             elif extid_target.object_type in (ObjectType.RELEASE, ObjectType.REVISION):
                 extid_targets.add(extid_target)
             else:
                 # Note that this case should never be reached unless there is a
                 # collision between a revision hash and some non-revision object's
                 # hash, but better safe than sorry.
                 logger.warning(
                     "%s is in the whitelist, but is not a revision/release.",
                     hash_to_hex(extid_target.object_type),
                 )
 
         if extid_targets:
             # This is a known package version, as we have an extid to reference it.
             # Let's return one of them.
 
             # If there is a release extid, return it.
             release_extid_targets = {
                 extid_target
                 for extid_target in extid_targets
                 if extid_target.object_type == ObjectType.RELEASE
             }
             if release_extid_targets:
                 assert len(release_extid_targets) == 1, release_extid_targets
                 return list(release_extid_targets)[0]
 
             # If there is no release extid (ie. if the package was only loaded with
             # older versions of this loader, which produced revision objects instead
             # of releases), return a revision extid.
             assert len(extid_targets) == 1, extid_targets
             extid_target = list(extid_targets)[0]
             assert extid_target.object_type == ObjectType.REVISION, extid_targets
             return extid_target
         else:
             # No target found (this is probably a new package version)
             return None
 
     def download_package(
         self, p_info: TPackageInfo, tmpdir: str
     ) -> List[Tuple[str, Mapping]]:
         """Download artifacts for a specific package. All downloads happen in
         in the tmpdir folder.
 
         Default implementation expects the artifacts package info to be
         about one artifact per package.
 
         Note that most implementation have 1 artifact per package. But some
         implementation have multiple artifacts per package (debian), some have
         none, the package is the artifact (gnu).
 
         Args:
             artifacts_package_info: Information on the package artifacts to
                 download (url, filename, etc...)
             tmpdir: Location to retrieve such artifacts
 
         Returns:
             List of (path, computed hashes)
 
         """
         try:
             return [download(p_info.url, dest=tmpdir, filename=p_info.filename)]
         except ContentDecodingError:
             # package might be erroneously marked as gzip compressed while is is not,
             # try to download its raw bytes again without attempting to uncompress
             # the input stream
             return [
                 download(
                     p_info.url,
                     dest=tmpdir,
                     filename=p_info.filename,
                     extra_request_headers={"Accept-Encoding": "identity"},
                 )
             ]
 
     def uncompress(
         self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]], dest: str
     ) -> str:
         """Uncompress the artifact(s) in the destination folder dest.
 
         Optionally, this could need to use the p_info dict for some more
         information (debian).
 
         """
         uncompressed_path = os.path.join(dest, "src")
         for a_path, _ in dl_artifacts:
             uncompress(a_path, dest=uncompressed_path)
         return uncompressed_path
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         """Return an extra dict of branches that are used to update the set of
         branches.
 
         """
         return {}
 
     def finalize_visit(
         self,
         *,
         snapshot: Optional[Snapshot],
         visit: OriginVisit,
         status_visit: str,
         status_load: str,
         failed_branches: List[str],
         errors: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """Finalize the visit:
 
         - flush eventual unflushed data to storage
         - update origin visit's status
         - return the task's status
 
         """
         self.storage.flush()
 
         snapshot_id: Optional[bytes] = None
         if snapshot and snapshot.id:  # to prevent the snapshot.id to b""
             snapshot_id = snapshot.id
         assert visit.visit
         visit_status = OriginVisitStatus(
             origin=self.url,
             visit=visit.visit,
             type=self.visit_type,
             date=now(),
             status=status_visit,
             snapshot=snapshot_id,
         )
         self.storage.origin_visit_status_add([visit_status])
         result: Dict[str, Any] = {
             "status": status_load,
         }
         if snapshot_id:
             result["snapshot_id"] = hash_to_hex(snapshot_id)
         if failed_branches:
             logger.warning("%d failed branches", len(failed_branches))
             for i, urls in enumerate(islice(failed_branches, 50)):
                 prefix_url = "Failed branches: " if i == 0 else ""
                 logger.warning("%s%s", prefix_url, urls)
 
         return result
 
     def load(self) -> Dict:
         """Load for a specific origin the associated contents.
 
         1. Get the list of versions in an origin.
 
         2. Get the snapshot from the previous run of the loader,
            and filter out versions that were already loaded, if their
            :term:`extids <extid>` match
 
         Then, for each remaining version in the origin
 
         3. Fetch the files for one package version By default, this can be
            implemented as a simple HTTP request. Loaders with more specific
            requirements can override this, e.g.: the PyPI loader checks the
            integrity of the downloaded files; the Debian loader has to download
            and check several files for one package version.
 
         4. Extract the downloaded files. By default, this would be a universal
            archive/tarball extraction.
 
            Loaders for specific formats can override this method (for instance,
            the Debian loader uses dpkg-source -x).
 
         5. Convert the extracted directory to a set of Software Heritage
            objects Using swh.model.from_disk.
 
         6. Extract the metadata from the unpacked directories This would only
            be applicable for "smart" loaders like npm (parsing the
            package.json), PyPI (parsing the PKG-INFO file) or Debian (parsing
            debian/changelog and debian/control).
 
            On "minimal-metadata" sources such as the GNU archive, the lister
            should provide the minimal set of metadata needed to populate the
            revision/release objects (authors, dates) as an argument to the
            task.
 
         7. Generate the revision/release objects for the given version. From
            the data generated at steps 3 and 4.
 
         end for each
 
         8. Generate and load the snapshot for the visit
 
         Using the revisions/releases collected at step 7., and the branch
         information from step 2., generate a snapshot and load it into the
         Software Heritage archive
 
         """
         status_load = "uneventful"  # either: eventful, uneventful, failed
         status_visit = "full"  # see swh.model.model.OriginVisitStatus
         snapshot = None
         failed_branches: List[str] = []
 
         # Prepare origin and origin_visit
         origin = Origin(url=self.url)
         try:
             self.storage.origin_add([origin])
             visit = list(
                 self.storage.origin_visit_add(
                     [
                         OriginVisit(
                             origin=self.url, date=self.visit_date, type=self.visit_type,
                         )
                     ]
                 )
             )[0]
         except Exception as e:
             logger.exception("Failed to initialize origin_visit for %s", self.url)
             sentry_sdk.capture_exception(e)
             return {"status": "failed"}
 
         # Get the previous snapshot for this origin. It is then used to see which
         # of the package's versions are already loaded in the archive.
         try:
             last_snapshot = self.last_snapshot()
             logger.debug("last snapshot: %s", last_snapshot)
         except Exception as e:
             logger.exception("Failed to get previous state for %s", self.url)
             sentry_sdk.capture_exception(e)
             return self.finalize_visit(
                 snapshot=snapshot,
                 visit=visit,
                 failed_branches=failed_branches,
                 status_visit="failed",
                 status_load="failed",
                 errors=[str(e)],
             )
 
         load_exceptions: List[Exception] = []
 
         # Get the list of all version names
         try:
             versions = self.get_versions()
         except NotFound as e:
             return self.finalize_visit(
                 snapshot=snapshot,
                 visit=visit,
                 failed_branches=failed_branches,
                 status_visit="not_found",
                 status_load="failed",
                 errors=[str(e)],
             )
         except Exception as e:
             return self.finalize_visit(
                 snapshot=snapshot,
                 visit=visit,
                 failed_branches=failed_branches,
                 status_visit="failed",
                 status_load="failed",
                 errors=[str(e)],
             )
 
         # Get the metadata of each version's package
         packages_info: List[Tuple[str, TPackageInfo]] = [
             (branch_name, p_info)
             for version in versions
             for (branch_name, p_info) in self.get_package_info(version)
         ]
 
         # Compute the ExtID of each of these packages
         known_extids = self._get_known_extids([p_info for (_, p_info) in packages_info])
 
         if last_snapshot is None:
             last_snapshot_targets: Set[Sha1Git] = set()
         else:
             last_snapshot_targets = {
                 branch.target for branch in last_snapshot.branches.values()
             }
 
         new_extids: Set[ExtID] = set()
         tmp_releases: Dict[str, List[Tuple[str, Sha1Git]]] = {
             version: [] for version in versions
         }
         errors = []
         for (branch_name, p_info) in packages_info:
             logger.debug("package_info: %s", p_info)
 
             # Check if the package was already loaded, using its ExtID
             swhid = self.resolve_object_from_extids(
                 known_extids, p_info, last_snapshot_targets
             )
 
             if swhid is not None and swhid.object_type == ObjectType.REVISION:
                 # This package was already loaded, but by an older version
                 # of this loader, which produced revisions instead of releases.
                 # Let's fetch the revision's data, and "upgrade" it into a release.
                 (rev,) = self.storage.revision_get([swhid.object_id])
                 if not rev:
                     logger.error(
                         "Failed to upgrade branch %s from revision to "
                         "release, %s is missing from the storage. "
                         "Falling back to re-loading from the origin.",
                         branch_name,
                         swhid,
                     )
             else:
                 rev = None
 
             if swhid is None or (swhid.object_type == ObjectType.REVISION and not rev):
                 # No matching revision or release found in the last snapshot, load it.
 
                 release_id = None
 
                 try:
                     res = self._load_release(p_info, origin)
                     if res:
                         (release_id, directory_id) = res
                         assert release_id
                         assert directory_id
                         self._load_extrinsic_directory_metadata(
                             p_info, release_id, directory_id
                         )
                     self.storage.flush()
                     status_load = "eventful"
                 except Exception as e:
                     self.storage.clear_buffers()
                     load_exceptions.append(e)
                     sentry_sdk.capture_exception(e)
                     error = f"Failed to load branch {branch_name} for {self.url}"
                     logger.exception(error)
                     failed_branches.append(branch_name)
                     errors.append(f"{error}: {e}")
                     continue
 
                 if release_id is None:
                     continue
 
                 add_extid = True
             elif swhid.object_type == ObjectType.REVISION:
                 # If 'rev' was None, the previous block would have run.
                 assert rev is not None
                 rel = rev2rel(rev, p_info.version)
                 self.storage.release_add([rel])
                 logger.debug("Upgraded %s to %s", swhid, rel.swhid())
                 release_id = rel.id
 
                 # Create a new extid for this package, so the next run of this loader
                 # will be able to find the new release, and use it (instead of the
                 # old revision)
                 add_extid = True
             elif swhid.object_type == ObjectType.RELEASE:
                 # This package was already loaded, nothing to do.
                 release_id = swhid.object_id
                 add_extid = False
             else:
                 assert False, f"Unexpected object type: {swhid}"
 
             assert release_id is not None
 
             if add_extid:
                 partial_extid = p_info.extid()
                 if partial_extid is not None:
-                    (extid_type, extid) = partial_extid
+                    (extid_type, extid_version, extid) = partial_extid
                     release_swhid = CoreSWHID(
                         object_type=ObjectType.RELEASE, object_id=release_id
                     )
                     new_extids.add(
-                        ExtID(extid_type=extid_type, extid=extid, target=release_swhid)
+                        ExtID(
+                            extid_type=extid_type,
+                            extid_version=extid_version,
+                            extid=extid,
+                            target=release_swhid,
+                        )
                     )
 
             tmp_releases[p_info.version].append((branch_name, release_id))
 
         if load_exceptions:
             status_visit = "partial"
 
         if not tmp_releases:
             # We could not load any releases; fail completely
             return self.finalize_visit(
                 snapshot=snapshot,
                 visit=visit,
                 failed_branches=failed_branches,
                 status_visit="failed",
                 status_load="failed",
                 errors=errors,
             )
 
         try:
             # Retrieve the default release version (the "latest" one)
             default_version = self.get_default_version()
             logger.debug("default version: %s", default_version)
             # Retrieve extra branches
             extra_branches = self.extra_branches()
             logger.debug("extra branches: %s", extra_branches)
 
             snapshot = self._load_snapshot(
                 default_version, tmp_releases, extra_branches
             )
             self.storage.flush()
         except Exception as e:
             error = f"Failed to build snapshot for origin {self.url}"
             logger.exception(error)
             errors.append(f"{error}: {e}")
             sentry_sdk.capture_exception(e)
             status_visit = "failed"
             status_load = "failed"
 
         if snapshot:
             try:
                 metadata_objects = self.build_extrinsic_snapshot_metadata(snapshot.id)
                 self._load_metadata_objects(metadata_objects)
             except Exception as e:
                 error = f"Failed to load extrinsic snapshot metadata for {self.url}"
                 logger.exception(error)
                 errors.append(f"{error}: {e}")
                 sentry_sdk.capture_exception(e)
                 status_visit = "partial"
                 status_load = "failed"
 
         try:
             metadata_objects = self.build_extrinsic_origin_metadata()
             self._load_metadata_objects(metadata_objects)
         except Exception as e:
             error = f"Failed to load extrinsic origin metadata for {self.url}"
             logger.exception(error)
             errors.append(f"{error}: {e}")
             sentry_sdk.capture_exception(e)
             status_visit = "partial"
             status_load = "failed"
 
         self._load_extids(new_extids)
 
         return self.finalize_visit(
             snapshot=snapshot,
             visit=visit,
             failed_branches=failed_branches,
             status_visit=status_visit,
             status_load=status_load,
             errors=errors,
         )
 
     def _load_directory(
         self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]], tmpdir: str
     ) -> Tuple[str, from_disk.Directory]:
         uncompressed_path = self.uncompress(dl_artifacts, dest=tmpdir)
         logger.debug("uncompressed_path: %s", uncompressed_path)
 
         directory = from_disk.Directory.from_disk(
             path=uncompressed_path.encode("utf-8"),
             max_content_length=self.max_content_size,
         )
 
         contents, skipped_contents, directories = from_disk.iter_directory(directory)
 
         logger.debug("Number of skipped contents: %s", len(skipped_contents))
         self.storage.skipped_content_add(skipped_contents)
         logger.debug("Number of contents: %s", len(contents))
         self.storage.content_add(contents)
 
         logger.debug("Number of directories: %s", len(directories))
         self.storage.directory_add(directories)
 
         return (uncompressed_path, directory)
 
     def _load_release(
         self, p_info: TPackageInfo, origin
     ) -> Optional[Tuple[Sha1Git, Sha1Git]]:
         """Does all the loading of a release itself:
 
         * downloads a package and uncompresses it
         * loads it from disk
         * adds contents, directories, and release to self.storage
         * returns (release_id, directory_id)
 
         Raises
             exception when unable to download or uncompress artifacts
 
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             dl_artifacts = self.download_package(p_info, tmpdir)
 
             (uncompressed_path, directory) = self._load_directory(dl_artifacts, tmpdir)
 
             # FIXME: This should be release. cf. D409
             release = self.build_release(
                 p_info, uncompressed_path, directory=directory.hash
             )
             if not release:
                 # Some artifacts are missing intrinsic metadata
                 # skipping those
                 return None
 
         metadata = [metadata for (filepath, metadata) in dl_artifacts]
 
         assert release.target is not None, release
         assert release.target_type == ModelObjectType.DIRECTORY, release
         metadata_target = ExtendedSWHID(
             object_type=ExtendedObjectType.DIRECTORY, object_id=release.target
         )
         original_artifact_metadata = RawExtrinsicMetadata(
             target=metadata_target,
             discovery_date=self.visit_date,
             authority=SWH_METADATA_AUTHORITY,
             fetcher=self.get_metadata_fetcher(),
             format="original-artifacts-json",
             metadata=json.dumps(metadata).encode(),
             origin=self.url,
             release=release.swhid(),
         )
         self._load_metadata_objects([original_artifact_metadata])
 
         logger.debug("Release: %s", release)
 
         self.storage.release_add([release])
         assert directory.hash
         return (release.id, directory.hash)
 
     def _load_snapshot(
         self,
         default_version: str,
         releases: Dict[str, List[Tuple[str, bytes]]],
         extra_branches: Dict[bytes, Mapping[str, Any]],
     ) -> Optional[Snapshot]:
         """Build snapshot out of the current releases stored and extra branches.
            Then load it in the storage.
 
         """
         logger.debug("releases: %s", releases)
         # Build and load the snapshot
         branches = {}  # type: Dict[bytes, Mapping[str, Any]]
         for version, branch_name_releases in releases.items():
             if version == default_version and len(branch_name_releases) == 1:
                 # only 1 branch (no ambiguity), we can create an alias
                 # branch 'HEAD'
                 branch_name, _ = branch_name_releases[0]
                 # except for some corner case (deposit)
                 if branch_name != "HEAD":
                     branches[b"HEAD"] = {
                         "target_type": "alias",
                         "target": branch_name.encode("utf-8"),
                     }
 
             for branch_name, target in branch_name_releases:
                 branches[branch_name.encode("utf-8")] = {
                     "target_type": "release",
                     "target": target,
                 }
 
         # Deal with extra-branches
         for name, branch_target in extra_branches.items():
             if name in branches:
                 logger.error("Extra branch '%s' has been ignored", name)
             else:
                 branches[name] = branch_target
 
         snapshot_data = {"branches": branches}
         logger.debug("snapshot: %s", snapshot_data)
         snapshot = Snapshot.from_dict(snapshot_data)
         logger.debug("snapshot: %s", snapshot)
         self.storage.snapshot_add([snapshot])
 
         return snapshot
 
     def get_loader_name(self) -> str:
         """Returns a fully qualified name of this loader."""
         return f"{self.__class__.__module__}.{self.__class__.__name__}"
 
     def get_loader_version(self) -> str:
         """Returns the version of the current loader."""
         module_name = self.__class__.__module__ or ""
         module_name_parts = module_name.split(".")
 
         # Iterate rootward through the package hierarchy until we find a parent of this
         # loader's module with a __version__ attribute.
         for prefix_size in range(len(module_name_parts), 0, -1):
             package_name = ".".join(module_name_parts[0:prefix_size])
             module = sys.modules[package_name]
             if hasattr(module, "__version__"):
                 return module.__version__  # type: ignore
 
         # If this loader's class has no parent package with a __version__,
         # it should implement it itself.
         raise NotImplementedError(
             f"Could not dynamically find the version of {self.get_loader_name()}."
         )
 
     def get_metadata_fetcher(self) -> MetadataFetcher:
         """Returns a MetadataFetcher instance representing this package loader;
         which is used to for adding provenance information to extracted
         extrinsic metadata, if any."""
         return MetadataFetcher(
             name=self.get_loader_name(), version=self.get_loader_version(), metadata={},
         )
 
     def get_metadata_authority(self) -> MetadataAuthority:
         """For package loaders that get extrinsic metadata, returns the authority
         the metadata are coming from.
         """
         raise NotImplementedError("get_metadata_authority")
 
     def get_extrinsic_origin_metadata(self) -> List[RawExtrinsicMetadataCore]:
         """Returns metadata items, used by build_extrinsic_origin_metadata."""
         return []
 
     def build_extrinsic_origin_metadata(self) -> List[RawExtrinsicMetadata]:
         """Builds a list of full RawExtrinsicMetadata objects, using
         metadata returned by get_extrinsic_origin_metadata."""
         metadata_items = self.get_extrinsic_origin_metadata()
         if not metadata_items:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in metadata_items:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     target=Origin(self.url).swhid(),
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                 )
             )
 
         return metadata_objects
 
     def get_extrinsic_snapshot_metadata(self) -> List[RawExtrinsicMetadataCore]:
         """Returns metadata items, used by build_extrinsic_snapshot_metadata."""
         return []
 
     def build_extrinsic_snapshot_metadata(
         self, snapshot_id: Sha1Git
     ) -> List[RawExtrinsicMetadata]:
         """Builds a list of full RawExtrinsicMetadata objects, using
         metadata returned by get_extrinsic_snapshot_metadata."""
         metadata_items = self.get_extrinsic_snapshot_metadata()
         if not metadata_items:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in metadata_items:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     target=ExtendedSWHID(
                         object_type=ExtendedObjectType.SNAPSHOT, object_id=snapshot_id
                     ),
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                     origin=self.url,
                 )
             )
 
         return metadata_objects
 
     def build_extrinsic_directory_metadata(
         self, p_info: TPackageInfo, release_id: Sha1Git, directory_id: Sha1Git,
     ) -> List[RawExtrinsicMetadata]:
         if not p_info.directory_extrinsic_metadata:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in p_info.directory_extrinsic_metadata:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     target=ExtendedSWHID(
                         object_type=ExtendedObjectType.DIRECTORY, object_id=directory_id
                     ),
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                     origin=self.url,
                     release=CoreSWHID(
                         object_type=ObjectType.RELEASE, object_id=release_id
                     ),
                 )
             )
 
         return metadata_objects
 
     def _load_extrinsic_directory_metadata(
         self, p_info: TPackageInfo, release_id: Sha1Git, directory_id: Sha1Git,
     ) -> None:
         metadata_objects = self.build_extrinsic_directory_metadata(
             p_info, release_id, directory_id
         )
         self._load_metadata_objects(metadata_objects)
 
     def _load_metadata_objects(
         self, metadata_objects: List[RawExtrinsicMetadata]
     ) -> None:
         if not metadata_objects:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return
 
         self._create_authorities(mo.authority for mo in metadata_objects)
         self._create_fetchers(mo.fetcher for mo in metadata_objects)
 
         self.storage.raw_extrinsic_metadata_add(metadata_objects)
 
     def _create_authorities(self, authorities: Iterable[MetadataAuthority]) -> None:
         deduplicated_authorities = {
             (authority.type, authority.url): authority for authority in authorities
         }
         if authorities:
             self.storage.metadata_authority_add(list(deduplicated_authorities.values()))
 
     def _create_fetchers(self, fetchers: Iterable[MetadataFetcher]) -> None:
         deduplicated_fetchers = {
             (fetcher.name, fetcher.version): fetcher for fetcher in fetchers
         }
         if fetchers:
             self.storage.metadata_fetcher_add(list(deduplicated_fetchers.values()))
 
     def _load_extids(self, extids: Set[ExtID]) -> None:
         if not extids:
             return
         try:
             self.storage.extid_add(list(extids))
         except Exception as e:
             logger.exception("Failed to load new ExtIDs for %s", self.url)
             sentry_sdk.capture_exception(e)
             # No big deal, it just means the next visit will load the same versions
             # again.
 
 
 def rev2rel(rev: Revision, version: str) -> Release:
     """Converts a revision to a release."""
     message = rev.message
     if message and not message.endswith(b"\n"):
         message += b"\n"
     return Release(
         name=version.encode(),
         message=message,
         target=rev.directory,
         target_type=ModelObjectType.DIRECTORY,
         synthetic=rev.synthetic,
         author=rev.author,
         date=rev.date,
     )
diff --git a/swh/loader/package/maven/loader.py b/swh/loader/package/maven/loader.py
index bf09e82..6ff99a7 100644
--- a/swh/loader/package/maven/loader.py
+++ b/swh/loader/package/maven/loader.py
@@ -1,231 +1,234 @@
 # Copyright (C) 2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from datetime import datetime, timezone
 import hashlib
 import json
 import logging
 from os import path
 import string
 from typing import (
     Any,
     Dict,
     Iterator,
     List,
     Mapping,
     Optional,
     OrderedDict,
     Sequence,
     Tuple,
 )
 from urllib.parse import urlparse
 
 import attr
 import iso8601
 import requests
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     PartialExtID,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import EMPTY_AUTHOR, release_name
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     ObjectType,
     RawExtrinsicMetadata,
     Release,
     Sha1Git,
     TimestampWithTimezone,
 )
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 
+EXTID_TYPE = "maven-jar"
+EXTID_VERSION = 0
+
 
 @attr.s
 class MavenPackageInfo(BasePackageInfo):
     time = attr.ib(type=datetime)
     """Timestamp of the last update of jar file on the server."""
     gid = attr.ib(type=str)
     """Group ID of the maven artifact"""
     aid = attr.ib(type=str)
     """Artifact ID of the maven artifact"""
     version = attr.ib(type=str)
     """Version of the maven artifact"""
 
     # default format for maven artifacts
     MANIFEST_FORMAT = string.Template("$gid $aid $version $url $time")
 
     def extid(self, manifest_format: Optional[string.Template] = None) -> PartialExtID:
         """Returns a unique intrinsic identifier of this package info
 
         ``manifest_format`` allows overriding the class' default MANIFEST_FORMAT"""
         manifest_format = manifest_format or self.MANIFEST_FORMAT
         manifest = manifest_format.substitute(
             {
                 "gid": self.gid,
                 "aid": self.aid,
                 "version": self.version,
                 "url": self.url,
                 "time": str(self.time),
             }
         )
-        return ("maven-jar", hashlib.sha256(manifest.encode()).digest())
+        return (EXTID_TYPE, EXTID_VERSION, hashlib.sha256(manifest.encode()).digest())
 
     @classmethod
     def from_metadata(cls, a_metadata: Dict[str, Any]) -> "MavenPackageInfo":
         url = a_metadata["url"]
         filename = a_metadata.get("filename")
         time = iso8601.parse_date(a_metadata["time"])
         time = time.astimezone(tz=timezone.utc)
         gid = a_metadata["gid"]
         aid = a_metadata["aid"]
         version = a_metadata["version"]
         return cls(
             url=url,
             filename=filename or path.split(url)[-1],
             time=time,
             gid=gid,
             aid=aid,
             version=version,
             directory_extrinsic_metadata=[
                 RawExtrinsicMetadataCore(
                     format="maven-json", metadata=json.dumps(a_metadata).encode(),
                 ),
             ],
         )
 
 
 class MavenLoader(PackageLoader[MavenPackageInfo]):
     """Load source code jar origin's artifact files into swh archive
 
     """
 
     visit_type = "maven"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         artifacts: Sequence[Dict[str, Any]],
         extid_manifest_format: Optional[str] = None,
         max_content_size: Optional[int] = None,
     ):
         f"""Loader constructor.
 
         For now, this is the lister's task output.
         There is one, and only one, artefact (jar or zip) per version, as guaranteed by
         the Maven coordinates system.
 
         Args:
             url: Origin url
             artifacts: List of single artifact information with keys:
 
                - **time**: the time of the last update of jar file on the server
                  as an iso8601 date string
 
                - **url**: the artifact url to retrieve filename
 
                - **filename**: optionally, the file's name
 
                - **gid**: artifact's groupId
 
                - **aid**: artifact's artifactId
 
                - **version**: artifact's version
 
             extid_manifest_format: template string used to format a manifest,
                 which is hashed to get the extid of a package.
                 Defaults to {MavenPackageInfo.MANIFEST_FORMAT!r}
 
         """
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.artifacts = artifacts  # assume order is enforced in the lister
         self.version_artifact: OrderedDict[str, Dict[str, Any]]
         self.version_artifact = OrderedDict(
             {str(jar["version"]): jar for jar in artifacts if jar["version"]}
         )
 
     def get_versions(self) -> Sequence[str]:
         return list(self.version_artifact.keys())
 
     def get_default_version(self) -> str:
         # Default version is the last item
         return self.artifacts[-1]["version"]
 
     def get_metadata_authority(self):
         p_url = urlparse(self.url)
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE,
             url=f"{p_url.scheme}://{p_url.netloc}/",
             metadata={},
         )
 
     def build_extrinsic_directory_metadata(
         self, p_info: MavenPackageInfo, release_id: Sha1Git, directory_id: Sha1Git,
     ) -> List[RawExtrinsicMetadata]:
         if not p_info.directory_extrinsic_metadata:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         # Get artifacts
         dir_ext_metadata = p_info.directory_extrinsic_metadata[0]
         a_metadata = json.loads(dir_ext_metadata.metadata)
         aid = a_metadata["aid"]
         version = a_metadata["version"]
 
         # Rebuild POM URL.
         pom_url = path.dirname(p_info.url)
         pom_url = f"{pom_url}/{aid}-{version}.pom"
 
         r = requests.get(pom_url, allow_redirects=True)
         if r.status_code == 200:
             metadata_pom = r.content
         else:
             metadata_pom = b""
 
         return super().build_extrinsic_directory_metadata(
             attr.evolve(
                 p_info,
                 directory_extrinsic_metadata=[
                     RawExtrinsicMetadataCore(
                         format="maven-pom", metadata=metadata_pom,
                     ),
                     dir_ext_metadata,
                 ],
             ),
             release_id=release_id,
             directory_id=directory_id,
         )
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, MavenPackageInfo]]:
         a_metadata = self.version_artifact[version]
         yield release_name(a_metadata["version"]), MavenPackageInfo.from_metadata(
             a_metadata
         )
 
     def build_release(
         self, p_info: MavenPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         msg = f"Synthetic release for archive at {p_info.url}\n".encode("utf-8")
         # time is an iso8601 date
         normalized_time = TimestampWithTimezone.from_datetime(p_info.time)
         return Release(
             name=p_info.version.encode(),
             message=msg,
             date=normalized_time,
             author=EMPTY_AUTHOR,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         last_snapshot = self.last_snapshot()
         return last_snapshot.to_dict()["branches"] if last_snapshot else {}
diff --git a/swh/loader/package/maven/tests/test_maven.py b/swh/loader/package/maven/tests/test_maven.py
index 3d2dff4..c23cf9a 100644
--- a/swh/loader/package/maven/tests/test_maven.py
+++ b/swh/loader/package/maven/tests/test_maven.py
@@ -1,615 +1,619 @@
 # Copyright (C) 2019-2021 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import hashlib
 import json
 from pathlib import Path
 import string
 
 import pytest
 
 from swh.loader.package import __version__
 from swh.loader.package.maven.loader import MavenLoader, MavenPackageInfo
 from swh.loader.package.utils import EMPTY_AUTHOR
 from swh.loader.tests import assert_last_visit_matches, check_snapshot, get_stats
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import (
     RawExtrinsicMetadata,
     Release,
     Snapshot,
     SnapshotBranch,
     TargetType,
     Timestamp,
     TimestampWithTimezone,
 )
 from swh.model.model import MetadataAuthority, MetadataAuthorityType, MetadataFetcher
 from swh.model.model import ObjectType as ModelObjectType
 from swh.model.swhids import CoreSWHID, ExtendedObjectType, ExtendedSWHID, ObjectType
 from swh.storage.algos.snapshot import snapshot_get_all_branches
 
 URL = "https://repo1.maven.org/maven2/"
 MVN_ARTIFACTS = [
     {
         "time": "2021-07-12 19:06:59.335000",
         "url": "https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.0/"
         + "sprova4j-0.1.0-sources.jar",
         "gid": "al.aldi",
         "aid": "sprova4j",
         "filename": "sprova4j-0.1.0-sources.jar",
         "version": "0.1.0",
     },
     {
         "time": "2021-07-12 19:37:05.534000",
         "url": "https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.1/"
         + "sprova4j-0.1.1-sources.jar",
         "gid": "al.aldi",
         "aid": "sprova4j",
         "filename": "sprova4j-0.1.1-sources.jar",
         "version": "0.1.1",
     },
 ]
 
 MVN_ARTIFACTS_POM = [
     "https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.0/sprova4j-0.1.0.pom",
     "https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.1/sprova4j-0.1.1.pom",
 ]
 
 _expected_new_contents_first_visit = [
     "cd807364cd7730022b3849f90ccf4bababbada84",
     "79e33dd52ebdf615e6696ae69add91cb990d81e2",
     "8002bd514156f05a0940ae14ef86eb0179cbd510",
     "23479553a6ccec30d377dee0496123a65d23fd8c",
     "07ffbebb933bc1660e448f07d8196c2b083797f9",
     "abf021b581f80035b56153c9aa27195b8d7ebbb8",
     "eec70ba80a6862ed2619727663b17eb0d9dfe131",
     "81a493dacb44dedf623f29ecf62c0e035bf698de",
     "bda85ed0bbecf8cddfea04234bee16f476f64fe4",
     "1ec91d561f5bdf59acb417086e04c54ead94e94e",
     "d517b423da707fa21378623f35facebff53cb59d",
     "3f0f21a764972d79e583908991c893c999613354",
     "a2dd4d7dfe6043baf9619081e4e29966989211af",
     "f62685cf0c6825a4097c949280b584cf0e16d047",
     "56afc1ea60cef6548ce0a34f44e91b0e4b063835",
     "cf7c740926e7ebc9ac8978a5c4f0e1e7a0e9e3af",
     "86ff828bea1c22ca3d50ed82569b9c59ce2c41a1",
     "1d0fa04454d9fec31d8ee3f35b58158ca1e28b15",
     "e90239a2c8d9ede61a29671a8b397a743e18fa34",
     "ce8851005d084aea089bcd8cf01052f4b234a823",
     "2c34ce622aa7fa68d104900840f66671718e6249",
     "e6a6fec32dcb3bee93c34fc11b0174a6b0b0ec6d",
     "405d3e1be4b658bf26de37f2c90c597b2796b9d7",
     "d0d2f5848721e04300e537826ef7d2d6d9441df0",
     "399c67e33e38c475fd724d283dd340f6a2e8dc91",
     "dea10c1111cc61ac1809fb7e88857e3db054959f",
 ]
 
 _expected_json_metadata = {
     "time": "2021-07-12 19:06:59.335000",
     "url": (
         "https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.0/"
         "sprova4j-0.1.0-sources.jar"
     ),
     "gid": "al.aldi",
     "aid": "sprova4j",
     "filename": "sprova4j-0.1.0-sources.jar",
     "version": "0.1.0",
 }
 _expected_pom_metadata = (
     """<?xml version="1.0" encoding="UTF-8"?>
 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 """
     'http://maven.apache.org/xsd/maven-4.0.0.xsd" '
     'xmlns="http://maven.apache.org/POM/4.0.0" '
     """xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <modelVersion>4.0.0</modelVersion>
   <groupId>al.aldi</groupId>
   <artifactId>sprova4j</artifactId>
   <version>0.1.0</version>
   <name>sprova4j</name>
   <description>Java client for Sprova Test Management</description>
   <url>https://github.com/aldialimucaj/sprova4j</url>
   <inceptionYear>2018</inceptionYear>
   <licenses>
     <license>
       <name>The Apache Software License, Version 2.0</name>
       <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
       <distribution>repo</distribution>
     </license>
   </licenses>
   <developers>
     <developer>
       <id>aldi</id>
       <name>Aldi Alimucaj</name>
       <email>aldi.alimucaj@gmail.com</email>
     </developer>
   </developers>
   <scm>
     <connection>scm:git:git://github.com/aldialimucaj/sprova4j.git</connection>
     <developerConnection>scm:git:git://github.com/aldialimucaj/sprova4j.git</developerConnection>
     <url>https://github.com/aldialimucaj/sprova4j</url>
   </scm>
   <dependencies>
     <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
       <version>2.8.3</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>com.squareup.okhttp3</groupId>
       <artifactId>okhttp</artifactId>
       <version>3.10.0</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>com.squareup.okio</groupId>
       <artifactId>okio</artifactId>
       <version>1.0.0</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>org.glassfish</groupId>
       <artifactId>javax.json</artifactId>
       <version>1.1.2</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>javax.json</groupId>
       <artifactId>javax.json-api</artifactId>
       <version>1.1.2</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
       <version>2.0.1.Final</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>com.squareup.okhttp3</groupId>
       <artifactId>mockwebserver</artifactId>
       <version>3.10.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
 </project>
 """
 )
 
 _expected_new_directories_first_visit = [
     "6c9de41e4cebb91a8368da1d89ae9873bd540ec3",
     "c1a2ee97fc47426d0179f94d223405336b5cd075",
     "9e1bdca292765a9528af18743bd793b80362c768",
     "193a7af634592ef27fb341762806f61e8fb8eab3",
     "a297aa21e3dbf138b370be3aae7a852dd403bbbb",
     "da84026119ae04022f007d5b3362e98d46d09045",
     "75bb915942a9c441ca62aeffc3b634f1ec9ce5e2",
     "0851d359283b2ad82b116c8d1b55ab14b1ec219c",
     "2bcbb8b723a025ee9a36b719cea229ed38c37e46",
 ]
 
 _expected_new_release_first_visit = "02e83c29ec094db581f939d2e238d0613a4f59ac"
 
 REL_MSG = (
     b"Synthetic release for archive at https://repo1.maven.org/maven2/al/aldi/"
     b"sprova4j/0.1.0/sprova4j-0.1.0-sources.jar\n"
 )
 
 REVISION_DATE = TimestampWithTimezone(
     timestamp=Timestamp(seconds=1626116819, microseconds=335000),
     offset=0,
     negative_utc=False,
 )
 
 
 @pytest.fixture
 def data_jar_1(datadir):
     content = Path(
         datadir, "https_maven.org", "sprova4j-0.1.0-sources.jar"
     ).read_bytes()
     return content
 
 
 @pytest.fixture
 def data_pom_1(datadir):
     content = Path(datadir, "https_maven.org", "sprova4j-0.1.0.pom").read_bytes()
     return content
 
 
 @pytest.fixture
 def data_jar_2(datadir):
     content = Path(
         datadir, "https_maven.org", "sprova4j-0.1.1-sources.jar"
     ).read_bytes()
     return content
 
 
 @pytest.fixture
 def data_pom_2(datadir):
     content = Path(datadir, "https_maven.org", "sprova4j-0.1.1.pom").read_bytes()
     return content
 
 
 def test_jar_visit_with_no_artifact_found(swh_storage, requests_mock_datadir):
     unknown_artifact_url = "https://ftp.g.o/unknown/8sync-0.1.0.tar.gz"
     loader = MavenLoader(
         swh_storage,
         unknown_artifact_url,
         artifacts=[
             {
                 "time": "2021-07-18 08:05:05.187000",
                 "url": unknown_artifact_url,  # unknown artifact
                 "filename": "8sync-0.1.0.tar.gz",
                 "gid": "al/aldi",
                 "aid": "sprova4j",
                 "version": "0.1.0",
             }
         ],
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "uneventful"
     assert actual_load_status["snapshot_id"] is not None
 
     expected_snapshot_id = "1a8893e6a86f444e8be8e7bda6cb34fb1735a00e"
     assert actual_load_status["snapshot_id"] == expected_snapshot_id
 
     stats = get_stats(swh_storage)
 
     assert_last_visit_matches(
         swh_storage, unknown_artifact_url, status="partial", type="maven"
     )
 
     assert {
         "content": 0,
         "directory": 0,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
 
 def test_jar_visit_with_release_artifact_no_prior_visit(
     swh_storage, requests_mock, data_jar_1, data_pom_1
 ):
     """With no prior visit, loading a jar ends up with 1 snapshot
 
     """
     requests_mock.get(MVN_ARTIFACTS[0]["url"], content=data_jar_1)
     requests_mock.get(MVN_ARTIFACTS_POM[0], content=data_pom_1)
     loader = MavenLoader(
         swh_storage, MVN_ARTIFACTS[0]["url"], artifacts=[MVN_ARTIFACTS[0]]
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
 
     expected_snapshot_first_visit_id = hash_to_bytes(
         "c5195b8ebd148649bf094561877964b131ab27e0"
     )
 
     expected_snapshot = Snapshot(
         id=expected_snapshot_first_visit_id,
         branches={
             b"HEAD": SnapshotBranch(
                 target_type=TargetType.ALIAS, target=b"releases/0.1.0",
             ),
             b"releases/0.1.0": SnapshotBranch(
                 target_type=TargetType.RELEASE,
                 target=hash_to_bytes(_expected_new_release_first_visit),
             ),
         },
     )
     actual_snapshot = snapshot_get_all_branches(
         swh_storage, hash_to_bytes(actual_load_status["snapshot_id"])
     )
 
     assert actual_snapshot == expected_snapshot
     check_snapshot(expected_snapshot, swh_storage)
 
     assert (
         hash_to_bytes(actual_load_status["snapshot_id"])
         == expected_snapshot_first_visit_id
     )
 
     stats = get_stats(swh_storage)
     assert_last_visit_matches(
         swh_storage, MVN_ARTIFACTS[0]["url"], status="full", type="maven"
     )
 
     expected_contents = map(hash_to_bytes, _expected_new_contents_first_visit)
     assert list(swh_storage.content_missing_per_sha1(expected_contents)) == []
 
     expected_dirs = map(hash_to_bytes, _expected_new_directories_first_visit)
     assert list(swh_storage.directory_missing(expected_dirs)) == []
 
     expected_rels = map(hash_to_bytes, {_expected_new_release_first_visit})
     assert list(swh_storage.release_missing(expected_rels)) == []
 
     rel_id = actual_snapshot.branches[b"releases/0.1.0"].target
     (rel,) = swh_storage.release_get([rel_id])
 
     assert rel == Release(
         id=hash_to_bytes(_expected_new_release_first_visit),
         name=b"0.1.0",
         message=REL_MSG,
         author=EMPTY_AUTHOR,
         date=REVISION_DATE,
         target_type=ModelObjectType.DIRECTORY,
         target=hash_to_bytes("6c9de41e4cebb91a8368da1d89ae9873bd540ec3"),
         synthetic=True,
         metadata=None,
     )
 
     assert {
         "content": len(_expected_new_contents_first_visit),
         "directory": len(_expected_new_directories_first_visit),
         "origin": 1,
         "origin_visit": 1,
         "release": 1,
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
 
 def test_jar_2_visits_without_change(
     swh_storage, requests_mock_datadir, requests_mock, data_jar_2, data_pom_2
 ):
     """With no prior visit, load a gnu project ends up with 1 snapshot
 
     """
     requests_mock.get(MVN_ARTIFACTS[1]["url"], content=data_jar_2)
     requests_mock.get(MVN_ARTIFACTS_POM[1], content=data_pom_2)
     loader = MavenLoader(
         swh_storage, MVN_ARTIFACTS[1]["url"], artifacts=[MVN_ARTIFACTS[1]]
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
 
     expected_snapshot_first_visit_id = hash_to_bytes(
         "91dcacee7a6d2b54f9cab14bc14cb86d22d2ac2b"
     )
 
     assert (
         hash_to_bytes(actual_load_status["snapshot_id"])
         == expected_snapshot_first_visit_id
     )
 
     assert_last_visit_matches(
         swh_storage, MVN_ARTIFACTS[1]["url"], status="full", type="maven"
     )
 
     actual_load_status2 = loader.load()
     assert actual_load_status2["status"] == "uneventful"
     assert actual_load_status2["snapshot_id"] is not None
     assert actual_load_status["snapshot_id"] == actual_load_status2["snapshot_id"]
 
     assert_last_visit_matches(
         swh_storage, MVN_ARTIFACTS[1]["url"], status="full", type="maven"
     )
 
     # Make sure we have only one entry in history for the pom fetch, one for
     # the actual download of jar, and that they're correct.
     urls_history = [str(req.url) for req in list(requests_mock_datadir.request_history)]
     assert urls_history == [
         MVN_ARTIFACTS[1]["url"],
         MVN_ARTIFACTS_POM[1],
     ]
 
 
 def test_metadatata(swh_storage, requests_mock, data_jar_1, data_pom_1):
     """With no prior visit, loading a jar ends up with 1 snapshot.
     Extrinsic metadata is the pom file associated to the source jar.
     """
     requests_mock.get(MVN_ARTIFACTS[0]["url"], content=data_jar_1)
     requests_mock.get(MVN_ARTIFACTS_POM[0], content=data_pom_1)
     loader = MavenLoader(
         swh_storage, MVN_ARTIFACTS[0]["url"], artifacts=[MVN_ARTIFACTS[0]]
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
 
     expected_release_id = hash_to_bytes(_expected_new_release_first_visit)
     release = swh_storage.release_get([expected_release_id])[0]
     assert release is not None
 
     release_swhid = CoreSWHID(
         object_type=ObjectType.RELEASE, object_id=expected_release_id
     )
     directory_swhid = ExtendedSWHID(
         object_type=ExtendedObjectType.DIRECTORY, object_id=release.target
     )
     metadata_authority = MetadataAuthority(
         type=MetadataAuthorityType.FORGE, url="https://repo1.maven.org/",
     )
 
     expected_metadata = [
         RawExtrinsicMetadata(
             target=directory_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.maven.loader.MavenLoader", version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="maven-pom",
             metadata=_expected_pom_metadata.encode(),
             origin=MVN_ARTIFACTS[0]["url"],
             release=release_swhid,
         ),
         RawExtrinsicMetadata(
             target=directory_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.maven.loader.MavenLoader", version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="maven-json",
             metadata=json.dumps(_expected_json_metadata).encode(),
             origin=MVN_ARTIFACTS[0]["url"],
             release=release_swhid,
         ),
     ]
 
     res = swh_storage.raw_extrinsic_metadata_get(directory_swhid, metadata_authority)
     assert res.next_page_token is None
     assert set(res.results) == set(expected_metadata)
 
 
 def test_metadatata_no_pom(swh_storage, requests_mock, data_jar_1):
     """With no prior visit, loading a jar ends up with 1 snapshot.
     Extrinsic metadata is None if the pom file cannot be retrieved.
     """
     requests_mock.get(MVN_ARTIFACTS[0]["url"], content=data_jar_1)
     requests_mock.get(MVN_ARTIFACTS_POM[0], status_code="404")
     loader = MavenLoader(
         swh_storage, MVN_ARTIFACTS[0]["url"], artifacts=[MVN_ARTIFACTS[0]]
     )
 
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
 
     expected_release_id = hash_to_bytes(_expected_new_release_first_visit)
     release = swh_storage.release_get([expected_release_id])[0]
     assert release is not None
 
     release_swhid = CoreSWHID(
         object_type=ObjectType.RELEASE, object_id=expected_release_id
     )
     directory_swhid = ExtendedSWHID(
         object_type=ExtendedObjectType.DIRECTORY, object_id=release.target
     )
     metadata_authority = MetadataAuthority(
         type=MetadataAuthorityType.FORGE, url="https://repo1.maven.org/",
     )
 
     expected_metadata = [
         RawExtrinsicMetadata(
             target=directory_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.maven.loader.MavenLoader", version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="maven-pom",
             metadata=b"",
             origin=MVN_ARTIFACTS[0]["url"],
             release=release_swhid,
         ),
         RawExtrinsicMetadata(
             target=directory_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.maven.loader.MavenLoader", version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="maven-json",
             metadata=json.dumps(_expected_json_metadata).encode(),
             origin=MVN_ARTIFACTS[0]["url"],
             release=release_swhid,
         ),
     ]
     res = swh_storage.raw_extrinsic_metadata_get(directory_swhid, metadata_authority)
     assert res.next_page_token is None
     assert set(res.results) == set(expected_metadata)
 
 
 def test_jar_extid():
     """Compute primary key should return the right identity
 
     """
 
     metadata = MVN_ARTIFACTS[0]
 
     p_info = MavenPackageInfo(**metadata)
 
     expected_manifest = (
         b"al.aldi sprova4j 0.1.0 "
         b"https://repo1.maven.org/maven2/al/aldi/sprova4j/0.1.0/sprova4j-0.1.0"
         b"-sources.jar 1626109619335"
     )
     for manifest_format in [
         string.Template("$aid $gid $version"),
         string.Template("$gid $aid"),
         string.Template("$gid $aid $version"),
     ]:
         actual_id = p_info.extid(manifest_format=manifest_format)
         assert actual_id != ("maven-jar", hashlib.sha256(expected_manifest).digest(),)
 
     for manifest_format, expected_manifest in [
         (None, "{gid} {aid} {version} {url} {time}".format(**metadata).encode()),
     ]:
         actual_id = p_info.extid(manifest_format=manifest_format)
-        assert actual_id == ("maven-jar", hashlib.sha256(expected_manifest).digest(),)
+        assert actual_id == (
+            "maven-jar",
+            0,
+            hashlib.sha256(expected_manifest).digest(),
+        )
 
     with pytest.raises(KeyError):
         p_info.extid(manifest_format=string.Template("$a $unknown_key"))
 
 
 def test_jar_snapshot_append(
     swh_storage,
     requests_mock_datadir,
     requests_mock,
     data_jar_1,
     data_pom_1,
     data_jar_2,
     data_pom_2,
 ):
 
     # first loading with a first artifact
     artifact1 = MVN_ARTIFACTS[0]
     url1 = artifact1["url"]
     requests_mock.get(url1, content=data_jar_1)
     requests_mock.get(MVN_ARTIFACTS_POM[0], content=data_pom_1)
     loader = MavenLoader(swh_storage, url1, [artifact1])
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, url1, status="full", type="maven")
 
     # check expected snapshot
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     branch_artifact1_name = f"releases/{artifact1['version']}".encode()
     assert b"HEAD" in snapshot.branches
     assert branch_artifact1_name in snapshot.branches
     assert snapshot.branches[b"HEAD"].target == branch_artifact1_name
 
     # second loading with a second artifact
     artifact2 = MVN_ARTIFACTS[1]
     url2 = artifact2["url"]
     requests_mock.get(url2, content=data_jar_2)
     requests_mock.get(MVN_ARTIFACTS_POM[1], content=data_pom_2)
     loader = MavenLoader(swh_storage, url2, [artifact2])
     actual_load_status = loader.load()
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] is not None
     assert_last_visit_matches(swh_storage, url2, status="full", type="maven")
 
     # check expected snapshot, should contain a new branch and the
     # branch for the first artifact
     snapshot = loader.last_snapshot()
     assert len(snapshot.branches) == 2
     branch_artifact2_name = f"releases/{artifact2['version']}".encode()
     assert b"HEAD" in snapshot.branches
     assert branch_artifact2_name in snapshot.branches
     assert branch_artifact1_name not in snapshot.branches
     assert snapshot.branches[b"HEAD"].target == branch_artifact2_name
diff --git a/swh/loader/package/nixguix/loader.py b/swh/loader/package/nixguix/loader.py
index 72ea922..004e4eb 100644
--- a/swh/loader/package/nixguix/loader.py
+++ b/swh/loader/package/nixguix/loader.py
@@ -1,282 +1,284 @@
 # Copyright (C) 2020-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import copy
 import json
 import logging
 import re
 from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple
 
 import attr
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     PartialExtID,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import EMPTY_AUTHOR, api_info, cached_method
 from swh.model import hashutil
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     ObjectType,
     Release,
     Sha1Git,
 )
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 
 EXTID_TYPE = "subresource-integrity"
 """The ExtID is an ASCII string, as defined by
 https://w3c.github.io/webappsec-subresource-integrity/"""
 
+EXTID_VERSION = 0
+
 
 @attr.s
 class NixGuixPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     integrity = attr.ib(type=str)
     """Hash of the archive, formatted as in the Subresource Integrity
     specification."""
 
     @classmethod
     def from_metadata(
         cls, metadata: Dict[str, Any], version: str
     ) -> "NixGuixPackageInfo":
         return cls(
             url=metadata["url"],
             filename=None,
             version=version,
             integrity=metadata["integrity"],
             raw_info=metadata,
         )
 
     def extid(self) -> PartialExtID:
-        return (EXTID_TYPE, self.integrity.encode("ascii"))
+        return (EXTID_TYPE, EXTID_VERSION, self.integrity.encode("ascii"))
 
 
 class NixGuixLoader(PackageLoader[NixGuixPackageInfo]):
     """Load sources from a sources.json file. This loader is used to load
     sources used by functional package manager (eg. Nix and Guix).
 
     """
 
     visit_type = "nixguix"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         unsupported_file_extensions: List[str] = [],
         max_content_size: Optional[int] = None,
     ):
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.provider_url = url
         self.unsupported_file_extensions = unsupported_file_extensions
 
     # Note: this could be renamed get_artifacts in the PackageLoader
     # base class.
     @cached_method
     def raw_sources(self):
         return retrieve_sources(self.url)
 
     @cached_method
     def supported_sources(self):
         raw_sources = self.raw_sources()
         return clean_sources(
             parse_sources(raw_sources), self.unsupported_file_extensions
         )
 
     @cached_method
     def integrity_by_url(self) -> Dict[str, str]:
         sources = self.supported_sources()
         return {s["urls"][0]: s["integrity"] for s in sources["sources"]}
 
     def get_versions(self) -> List[str]:
         """The first mirror of the mirror list is used as branch name in the
         snapshot.
 
         """
         return list(self.integrity_by_url().keys())
 
     def get_metadata_authority(self):
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE, url=self.url, metadata={},
         )
 
     def get_extrinsic_snapshot_metadata(self):
         return [
             RawExtrinsicMetadataCore(
                 format="nixguix-sources-json", metadata=self.raw_sources(),
             ),
         ]
 
     # Note: this could be renamed get_artifact_info in the PackageLoader
     # base class.
     def get_package_info(self, url) -> Iterator[Tuple[str, NixGuixPackageInfo]]:
         # TODO: try all mirrors and not only the first one. A source
         # can be fetched from several urls, called mirrors. We
         # currently only use the first one, but if the first one
         # fails, we should try the second one and so on.
         integrity = self.integrity_by_url()[url]
         p_info = NixGuixPackageInfo.from_metadata(
             {"url": url, "integrity": integrity}, version=url
         )
         yield url, p_info
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         """We add a branch to the snapshot called 'evaluation' pointing to the
         revision used to generate the sources.json file. This revision
         is specified in the sources.json file itself. For the nixpkgs
         origin, this revision is coming from the
         github.com/nixos/nixpkgs repository.
 
         Note this repository is not loaded explicitly. So, this
         pointer can target a nonexistent revision for a time. However,
         the github and gnu loaders are supposed to load this revision
         and should create the revision pointed by this branch.
 
         This branch can be used to identify the snapshot associated to
         a Nix/Guix evaluation.
 
         """
         # The revision used to create the sources.json file. For Nix,
         # this revision belongs to the github.com/nixos/nixpkgs
         # repository
         revision = self.supported_sources()["revision"]
         return {
             b"evaluation": {
                 "target_type": "revision",
                 "target": hashutil.hash_to_bytes(revision),
             }
         }
 
     def build_release(
         self, p_info: NixGuixPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         return Release(
             name=p_info.version.encode(),
             message=None,
             author=EMPTY_AUTHOR,
             date=None,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
 
 
 def retrieve_sources(url: str) -> bytes:
     """Retrieve sources. Potentially raise NotFound error."""
     return api_info(url, allow_redirects=True)
 
 
 def parse_sources(raw_sources: bytes) -> Dict[str, Any]:
     return json.loads(raw_sources.decode("utf-8"))
 
 
 def make_pattern_unsupported_file_extension(unsupported_file_extensions: List[str],):
     """Make a regexp pattern for unsupported file extension out of a list
     of unsupported archive extension list.
 
     """
     return re.compile(
         rf".*\.({'|'.join(map(re.escape, unsupported_file_extensions))})$", re.DOTALL
     )
 
 
 def clean_sources(
     sources: Dict[str, Any], unsupported_file_extensions=[]
 ) -> Dict[str, Any]:
     """Validate and clean the sources structure. First, ensure all top level keys are
     present. Then, walk the sources list and remove sources that do not contain required
     keys.
 
     Filter out source entries whose:
     - required keys are missing
     - source type is not supported
     - urls attribute type is not a list
     - extension is known not to be supported by the loader
 
     Raises:
         ValueError if:
         - a required top level key is missing
         - top-level version is not 1
 
     Returns:
         source Dict cleaned up
 
     """
     pattern_unsupported_file = make_pattern_unsupported_file_extension(
         unsupported_file_extensions
     )
     # Required top level keys
     required_keys = ["version", "revision", "sources"]
     missing_keys = []
     for required_key in required_keys:
         if required_key not in sources:
             missing_keys.append(required_key)
 
     if missing_keys != []:
         raise ValueError(
             f"sources structure invalid, missing: {','.join(missing_keys)}"
         )
 
     # Only the version 1 is currently supported
     version = int(sources["version"])
     if version != 1:
         raise ValueError(
             f"The sources structure version '{sources['version']}' is not supported"
         )
 
     # If a source doesn't contain required attributes, this source is
     # skipped but others could still be archived.
     verified_sources = []
     for source in sources["sources"]:
         valid = True
         required_keys = ["urls", "integrity", "type"]
         for required_key in required_keys:
             if required_key not in source:
                 logger.info(
                     f"Skip source '{source}' because key '{required_key}' is missing",
                 )
                 valid = False
 
         if valid and source["type"] != "url":
             logger.info(
                 f"Skip source '{source}' because the type {source['type']} "
                 "is not supported",
             )
             valid = False
 
         if valid and not isinstance(source["urls"], list):
             logger.info(
                 f"Skip source {source} because the urls attribute is not a list"
             )
             valid = False
 
         if valid and len(source["urls"]) > 0:  # Filter out unsupported archives
             supported_sources: List[str] = []
             for source_url in source["urls"]:
                 if pattern_unsupported_file.match(source_url):
                     logger.info(f"Skip unsupported artifact url {source_url}")
                     continue
                 supported_sources.append(source_url)
 
             if len(supported_sources) == 0:
                 logger.info(
                     f"Skip source {source} because urls only reference "
                     "unsupported artifacts. Unsupported "
                     f"artifacts so far: {pattern_unsupported_file}"
                 )
                 continue
 
             new_source = copy.deepcopy(source)
             new_source["urls"] = supported_sources
             verified_sources.append(new_source)
 
     sources["sources"] = verified_sources
     return sources
diff --git a/swh/loader/package/npm/loader.py b/swh/loader/package/npm/loader.py
index 90e579a..32b4db1 100644
--- a/swh/loader/package/npm/loader.py
+++ b/swh/loader/package/npm/loader.py
@@ -1,295 +1,296 @@
 # Copyright (C) 2019-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from codecs import BOM_UTF8
 import json
 import logging
 import os
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 from urllib.parse import quote
 
 import attr
 import chardet
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     PartialExtID,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import api_info, cached_method, release_name
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     ObjectType,
     Person,
     Release,
     Sha1Git,
     TimestampWithTimezone,
 )
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 
 
 EMPTY_PERSON = Person(fullname=b"", name=None, email=None)
 
 
 EXTID_TYPE = "npm-archive-sha1"
+EXTID_VERSION = 0
 
 
 @attr.s
 class NpmPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     date = attr.ib(type=Optional[str])
     shasum = attr.ib(type=str)
     """sha1 checksum"""
 
     @classmethod
     def from_metadata(
         cls, project_metadata: Dict[str, Any], version: str
     ) -> "NpmPackageInfo":
         package_metadata = project_metadata["versions"][version]
         url = package_metadata["dist"]["tarball"]
 
         # No date available in intrinsic metadata: retrieve it from the API
         # metadata, using the version number that the API claims this package
         # has.
         extrinsic_version = package_metadata["version"]
 
         if "time" in project_metadata:
             date = project_metadata["time"][extrinsic_version]
         elif "mtime" in package_metadata:
             date = package_metadata["mtime"]
         else:
             date = None
 
         return cls(
             url=url,
             filename=os.path.basename(url),
             date=date,
             shasum=package_metadata["dist"]["shasum"],
             version=extrinsic_version,
             raw_info=package_metadata,
             directory_extrinsic_metadata=[
                 RawExtrinsicMetadataCore(
                     format="replicate-npm-package-json",
                     metadata=json.dumps(package_metadata).encode(),
                 )
             ],
         )
 
     def extid(self) -> PartialExtID:
-        return (EXTID_TYPE, hash_to_bytes(self.shasum))
+        return (EXTID_TYPE, EXTID_VERSION, hash_to_bytes(self.shasum))
 
 
 class NpmLoader(PackageLoader[NpmPackageInfo]):
     """Load npm origin's artifact releases into swh archive.
 
     """
 
     visit_type = "npm"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         max_content_size: Optional[int] = None,
     ):
         """Constructor
 
         Args
             str: origin url (e.g. https://www.npmjs.com/package/<package-name>)
         """
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.package_name = url.split("https://www.npmjs.com/package/")[1]
         safe_name = quote(self.package_name, safe="")
         self.provider_url = f"https://replicate.npmjs.com/{safe_name}/"
         self._info: Dict[str, Any] = {}
         self._versions = None
 
     @cached_method
     def _raw_info(self) -> bytes:
         return api_info(self.provider_url)
 
     @cached_method
     def info(self) -> Dict:
         """Return the project metadata information (fetched from npm registry)
 
         """
         return json.loads(self._raw_info())
 
     def get_versions(self) -> Sequence[str]:
         return sorted(list(self.info()["versions"].keys()))
 
     def get_default_version(self) -> str:
         return self.info()["dist-tags"].get("latest", "")
 
     def get_metadata_authority(self):
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE, url="https://npmjs.com/", metadata={},
         )
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, NpmPackageInfo]]:
         p_info = NpmPackageInfo.from_metadata(
             project_metadata=self.info(), version=version
         )
         yield release_name(version), p_info
 
     def build_release(
         self, p_info: NpmPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         i_metadata = extract_intrinsic_metadata(uncompressed_path)
         if not i_metadata:
             return None
         author = extract_npm_package_author(i_metadata)
         msg = (
             f"Synthetic release for NPM source package {self.package_name} "
             f"version {p_info.version}\n"
         )
 
         if p_info.date is None:
             url = p_info.url
             artifact_name = os.path.basename(url)
             raise ValueError(
                 "Origin %s: Cannot determine upload time for artifact %s."
                 % (p_info.url, artifact_name)
             )
 
         date = TimestampWithTimezone.from_iso8601(p_info.date)
 
         # FIXME: this is to remain bug-compatible with earlier versions:
         date = attr.evolve(date, timestamp=attr.evolve(date.timestamp, microseconds=0))
 
         r = Release(
             name=p_info.version.encode(),
             message=msg.encode(),
             author=author,
             date=date,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
         return r
 
 
 def _author_str(author_data: Union[Dict, List, str]) -> str:
     """Parse author from package.json author fields
 
     """
     if isinstance(author_data, dict):
         author_str = ""
         name = author_data.get("name")
         if name is not None:
             if isinstance(name, str):
                 author_str += name
             elif isinstance(name, list):
                 author_str += _author_str(name[0]) if len(name) > 0 else ""
         email = author_data.get("email")
         if email is not None:
             author_str += f" <{email}>"
         result = author_str
     elif isinstance(author_data, list):
         result = _author_str(author_data[0]) if len(author_data) > 0 else ""
     else:
         result = author_data
     return result
 
 
 def extract_npm_package_author(package_json: Dict[str, Any]) -> Person:
     """
     Extract package author from a ``package.json`` file content and
     return it in swh format.
 
     Args:
         package_json: Dict holding the content of parsed
             ``package.json`` file
 
     Returns:
         Person
 
     """
     for author_key in ("author", "authors"):
         if author_key in package_json:
             author_data = package_json[author_key]
             if author_data is None:
                 return EMPTY_PERSON
             author_str = _author_str(author_data)
             return Person.from_fullname(author_str.encode())
 
     return EMPTY_PERSON
 
 
 def _lstrip_bom(s, bom=BOM_UTF8):
     if s.startswith(bom):
         return s[len(bom) :]
     else:
         return s
 
 
 def load_json(json_bytes):
     """
     Try to load JSON from bytes and return a dictionary.
 
     First try to decode from utf-8. If the decoding failed,
     try to detect the encoding and decode again with replace
     error handling.
 
     If JSON is malformed, an empty dictionary will be returned.
 
     Args:
         json_bytes (bytes): binary content of a JSON file
 
     Returns:
         dict: JSON data loaded in a dictionary
     """
     json_data = {}
     try:
         json_str = _lstrip_bom(json_bytes).decode("utf-8")
     except UnicodeDecodeError:
         encoding = chardet.detect(json_bytes)["encoding"]
         if encoding:
             json_str = json_bytes.decode(encoding, "replace")
     try:
         json_data = json.loads(json_str)
     except json.decoder.JSONDecodeError:
         pass
     return json_data
 
 
 def extract_intrinsic_metadata(dir_path: str) -> Dict:
     """Given an uncompressed path holding the pkginfo file, returns a
        pkginfo parsed structure as a dict.
 
        The release artifact contains at their root one folder. For example:
        $ tar tvf zprint-0.0.6.tar.gz
        drwxr-xr-x root/root         0 2018-08-22 11:01 zprint-0.0.6/
        ...
 
     Args:
 
         dir_path (str): Path to the uncompressed directory
                         representing a release artifact from npm.
 
     Returns:
         the pkginfo parsed structure as a dict if any or None if
         none was present.
 
     """
     # Retrieve the root folder of the archive
     if not os.path.exists(dir_path):
         return {}
     lst = os.listdir(dir_path)
     if len(lst) == 0:
         return {}
     project_dirname = lst[0]
     package_json_path = os.path.join(dir_path, project_dirname, "package.json")
     if not os.path.exists(package_json_path):
         return {}
     with open(package_json_path, "rb") as package_json_file:
         package_json_bytes = package_json_file.read()
         return load_json(package_json_bytes)
diff --git a/swh/loader/package/pypi/loader.py b/swh/loader/package/pypi/loader.py
index c963df1..3ceca15 100644
--- a/swh/loader/package/pypi/loader.py
+++ b/swh/loader/package/pypi/loader.py
@@ -1,250 +1,251 @@
 # Copyright (C) 2019-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 import logging
 import os
 from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
 from urllib.parse import urlparse
 
 import attr
 from pkginfo import UnpackedSDist
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     PartialExtID,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import EMPTY_AUTHOR, api_info, cached_method, release_name
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     ObjectType,
     Person,
     Release,
     Sha1Git,
     TimestampWithTimezone,
 )
 from swh.storage.interface import StorageInterface
 
 logger = logging.getLogger(__name__)
 
 
 EXTID_TYPE = "pypi-archive-sha256"
+EXTID_VERSION = 0
 
 
 @attr.s
 class PyPIPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     name = attr.ib(type=str)
     comment_text = attr.ib(type=Optional[str])
     sha256 = attr.ib(type=str)
     upload_time = attr.ib(type=str)
 
     @classmethod
     def from_metadata(
         cls, metadata: Dict[str, Any], name: str, version: str
     ) -> "PyPIPackageInfo":
         return cls(
             url=metadata["url"],
             filename=metadata["filename"],
             version=version,
             raw_info=metadata,
             name=name,
             comment_text=metadata.get("comment_text"),
             sha256=metadata["digests"]["sha256"],
             upload_time=metadata["upload_time"],
             directory_extrinsic_metadata=[
                 RawExtrinsicMetadataCore(
                     format="pypi-project-json", metadata=json.dumps(metadata).encode(),
                 )
             ],
         )
 
     def extid(self) -> PartialExtID:
-        return (EXTID_TYPE, hash_to_bytes(self.sha256))
+        return (EXTID_TYPE, EXTID_VERSION, hash_to_bytes(self.sha256))
 
 
 class PyPILoader(PackageLoader[PyPIPackageInfo]):
     """Load pypi origin's artifact releases into swh archive.
 
     """
 
     visit_type = "pypi"
 
     def __init__(
         self,
         storage: StorageInterface,
         url: str,
         max_content_size: Optional[int] = None,
     ):
         super().__init__(storage=storage, url=url, max_content_size=max_content_size)
         self.provider_url = pypi_api_url(self.url)
 
     @cached_method
     def _raw_info(self) -> bytes:
         return api_info(self.provider_url)
 
     @cached_method
     def info(self) -> Dict:
         """Return the project metadata information (fetched from pypi registry)
 
         """
         return json.loads(self._raw_info())
 
     def get_versions(self) -> Sequence[str]:
         return self.info()["releases"].keys()
 
     def get_default_version(self) -> str:
         return self.info()["info"]["version"]
 
     def get_metadata_authority(self):
         p_url = urlparse(self.url)
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE,
             url=f"{p_url.scheme}://{p_url.netloc}/",
             metadata={},
         )
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, PyPIPackageInfo]]:
         res = []
         for meta in self.info()["releases"][version]:
             # process only standard sdist archives
             if meta["packagetype"] != "sdist" or meta["filename"].lower().endswith(
                 (".deb", ".egg", ".rpm", ".whl")
             ):
                 continue
 
             p_info = PyPIPackageInfo.from_metadata(
                 meta, name=self.info()["info"]["name"], version=version
             )
             res.append((version, p_info))
 
         if len(res) == 1:
             version, p_info = res[0]
             yield release_name(version), p_info
         else:
             for version, p_info in res:
                 yield release_name(version, p_info.filename), p_info
 
     def build_release(
         self, p_info: PyPIPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Release]:
         i_metadata = extract_intrinsic_metadata(uncompressed_path)
         if not i_metadata:
             return None
 
         # from intrinsic metadata
         version_ = i_metadata.get("version", p_info.version)
         author_ = author(i_metadata)
 
         if p_info.comment_text:
             msg = p_info.comment_text
         else:
             msg = (
                 f"Synthetic release for PyPI source package {p_info.name} "
                 f"version {version_}\n"
             )
 
         date = TimestampWithTimezone.from_iso8601(p_info.upload_time)
 
         return Release(
             name=p_info.version.encode(),
             message=msg.encode(),
             author=author_,
             date=date,
             target=directory,
             target_type=ObjectType.DIRECTORY,
             synthetic=True,
         )
 
 
 def pypi_api_url(url: str) -> str:
     """Compute api url from a project url
 
     Args:
         url (str): PyPI instance's url (e.g: https://pypi.org/project/requests)
         This deals with correctly transforming the project's api url (e.g
         https://pypi.org/pypi/requests/json)
 
     Returns:
         api url
 
     """
     p_url = urlparse(url)
     project_name = p_url.path.rstrip("/").split("/")[-1]
     url = "%s://%s/pypi/%s/json" % (p_url.scheme, p_url.netloc, project_name)
     return url
 
 
 def extract_intrinsic_metadata(dir_path: str) -> Dict:
     """Given an uncompressed path holding the pkginfo file, returns a
        pkginfo parsed structure as a dict.
 
        The release artifact contains at their root one folder. For example:
        $ tar tvf zprint-0.0.6.tar.gz
        drwxr-xr-x root/root         0 2018-08-22 11:01 zprint-0.0.6/
        ...
 
     Args:
 
         dir_path (str): Path to the uncompressed directory
                         representing a release artifact from pypi.
 
     Returns:
         the pkginfo parsed structure as a dict if any or None if
         none was present.
 
     """
     # Retrieve the root folder of the archive
     if not os.path.exists(dir_path):
         return {}
     lst = os.listdir(dir_path)
     if len(lst) != 1:
         return {}
     project_dirname = lst[0]
     pkginfo_path = os.path.join(dir_path, project_dirname, "PKG-INFO")
     if not os.path.exists(pkginfo_path):
         return {}
     pkginfo = UnpackedSDist(pkginfo_path)
     raw = pkginfo.__dict__
     raw.pop("filename")  # this gets added with the ondisk location
     return raw
 
 
 def author(data: Dict) -> Person:
     """Given a dict of project/release artifact information (coming from
        PyPI), returns an author subset.
 
     Args:
         data (dict): Representing either artifact information or
                      release information.
 
     Returns:
         swh-model dict representing a person.
 
     """
     name = data.get("author")
     email = data.get("author_email")
     fullname = None  # type: Optional[str]
 
     if email:
         fullname = "%s <%s>" % (name, email)
     else:
         fullname = name
 
     if not fullname:
         return EMPTY_AUTHOR
 
     if name is not None:
         name = name.encode("utf-8")
 
     if email is not None:
         email = email.encode("utf-8")
 
     return Person(fullname=fullname.encode("utf-8"), name=name, email=email)
diff --git a/swh/loader/package/tests/test_loader.py b/swh/loader/package/tests/test_loader.py
index 559334e..3b73f98 100644
--- a/swh/loader/package/tests/test_loader.py
+++ b/swh/loader/package/tests/test_loader.py
@@ -1,452 +1,452 @@
 # Copyright (C) 2019-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 import hashlib
 import logging
 import string
 from unittest.mock import Mock, call, patch
 
 import attr
 import pytest
 
 from swh.loader.package.loader import BasePackageInfo, PackageLoader
 from swh.model.model import (
     Origin,
     OriginVisit,
     OriginVisitStatus,
     Person,
     Release,
     Revision,
     RevisionType,
     Snapshot,
     SnapshotBranch,
     TargetType,
     TimestampWithTimezone,
 )
 from swh.model.model import ExtID
 from swh.model.model import ObjectType as ModelObjectType
 from swh.model.swhids import CoreSWHID, ObjectType
 from swh.storage import get_storage
 from swh.storage.algos.snapshot import snapshot_get_latest
 
 
 class FakeStorage:
     def origin_add(self, origins):
         raise ValueError("We refuse to add an origin")
 
     def origin_visit_get_latest(self, origin):
         return None
 
 
 class FakeStorage2(FakeStorage):
     def origin_add(self, origins):
         pass
 
     def origin_visit_add(self, visits):
         raise ValueError("We refuse to add an origin visit")
 
 
 class StubPackageInfo(BasePackageInfo):
     pass
 
 
 class StubPackageLoader(PackageLoader[StubPackageInfo]):
     def get_versions(self):
         return ["v1.0", "v2.0", "v3.0", "v4.0"]
 
     def get_package_info(self, version):
         p_info = StubPackageInfo(
             "http://example.org", f"example-{version}.tar", version=version
         )
         extid_type = "extid-type1" if version in ("v1.0", "v2.0") else "extid-type2"
         # Versions 1.0 and 2.0 have an extid of a given type, v3.0 has an extid
         # of a different type
         patch.object(
             p_info,
             "extid",
-            return_value=(extid_type, f"extid-of-{version}".encode()),
+            return_value=(extid_type, 0, f"extid-of-{version}".encode()),
             autospec=True,
         ).start()
         yield (f"branch-{version}", p_info)
 
     def _load_release(self, p_info, origin):
         return None
 
 
 def test_loader_origin_visit_failure(swh_storage):
     """Failure to add origin or origin visit should failed immediately
 
     """
     loader = PackageLoader(swh_storage, "some-url")
     loader.storage = FakeStorage()
 
     actual_load_status = loader.load()
     assert actual_load_status == {"status": "failed"}
 
     loader.storage = FakeStorage2()
 
     actual_load_status2 = loader.load()
     assert actual_load_status2 == {"status": "failed"}
 
 
 def test_resolve_object_from_extids() -> None:
     loader = PackageLoader(None, None)  # type: ignore
 
     p_info = Mock(wraps=BasePackageInfo(None, None, None))  # type: ignore
 
     # The PackageInfo does not support extids
     p_info.extid.return_value = None
     known_extids = {
-        ("extid-type", b"extid-of-aaaa"): [
+        ("extid-type", 0, b"extid-of-aaaa"): [
             CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"a" * 20),
         ]
     }
     whitelist = {b"unused"}
     assert loader.resolve_object_from_extids(known_extids, p_info, whitelist) is None
 
     # Some known extid, and the PackageInfo is not one of them (ie. cache miss)
-    p_info.extid.return_value = ("extid-type", b"extid-of-cccc")
+    p_info.extid.return_value = ("extid-type", 0, b"extid-of-cccc")
     assert loader.resolve_object_from_extids(known_extids, p_info, whitelist) is None
 
     # Some known extid, and the PackageInfo is one of them (ie. cache hit),
     # but the target release was not in the previous snapshot
-    p_info.extid.return_value = ("extid-type", b"extid-of-aaaa")
+    p_info.extid.return_value = ("extid-type", 0, b"extid-of-aaaa")
     assert loader.resolve_object_from_extids(known_extids, p_info, whitelist) is None
 
     # Some known extid, and the PackageInfo is one of them (ie. cache hit),
     # and the target release was in the previous snapshot
     whitelist = {b"a" * 20}
     assert loader.resolve_object_from_extids(
         known_extids, p_info, whitelist
     ) == CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"a" * 20)
 
     # Same as before, but there is more than one extid, and only one is an allowed
     # release
     whitelist = {b"a" * 20}
     known_extids = {
-        ("extid-type", b"extid-of-aaaa"): [
+        ("extid-type", 0, b"extid-of-aaaa"): [
             CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"b" * 20),
             CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"a" * 20),
         ]
     }
     assert loader.resolve_object_from_extids(
         known_extids, p_info, whitelist
     ) == CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"a" * 20)
 
 
 def test_load_get_known_extids() -> None:
     """Checks PackageLoader.load() fetches known extids efficiently"""
     storage = Mock(wraps=get_storage("memory"))
 
     loader = StubPackageLoader(storage, "http://example.org")
 
     loader.load()
 
     # Calls should be grouped by extid type
     storage.extid_get_from_extid.assert_has_calls(
         [
-            call("extid-type1", [b"extid-of-v1.0", b"extid-of-v2.0"]),
-            call("extid-type2", [b"extid-of-v3.0", b"extid-of-v4.0"]),
+            call("extid-type1", [b"extid-of-v1.0", b"extid-of-v2.0"], version=0),
+            call("extid-type2", [b"extid-of-v3.0", b"extid-of-v4.0"], version=0),
         ],
         any_order=True,
     )
 
 
 def test_load_extids() -> None:
     """Checks PackageLoader.load() skips iff it should, and writes (only)
     the new ExtIDs"""
     storage = get_storage("memory")
 
     origin = "http://example.org"
     rel1_swhid = CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"a" * 20)
     rel2_swhid = CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"b" * 20)
     rel3_swhid = CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"c" * 20)
     rel4_swhid = CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"d" * 20)
     dir_swhid = CoreSWHID(object_type=ObjectType.DIRECTORY, object_id=b"e" * 20)
 
     # Results of a previous load
     storage.extid_add(
         [
             ExtID("extid-type1", b"extid-of-v1.0", rel1_swhid),
             ExtID("extid-type2", b"extid-of-v2.0", rel2_swhid),
         ]
     )
     last_snapshot = Snapshot(
         branches={
             b"v1.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel1_swhid.object_id
             ),
             b"v2.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel2_swhid.object_id
             ),
             b"v3.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel3_swhid.object_id
             ),
         }
     )
     storage.snapshot_add([last_snapshot])
     date = datetime.datetime.now(tz=datetime.timezone.utc)
     storage.origin_add([Origin(url=origin)])
     storage.origin_visit_add(
         [OriginVisit(origin="http://example.org", visit=1, date=date, type="tar")]
     )
     storage.origin_visit_status_add(
         [
             OriginVisitStatus(
                 origin=origin,
                 visit=1,
                 status="full",
                 date=date,
                 snapshot=last_snapshot.id,
             )
         ]
     )
 
     loader = StubPackageLoader(storage, "http://example.org")
     patch.object(
         loader,
         "_load_release",
         return_value=(rel4_swhid.object_id, dir_swhid.object_id),
         autospec=True,
     ).start()
 
     loader.load()
 
     assert loader._load_release.mock_calls == [  # type: ignore
         # v1.0: not loaded because there is already its (extid_type, extid, rel)
         #       in the storage.
         # v2.0: loaded, because there is already a similar extid, but different type
         call(StubPackageInfo(origin, "example-v2.0.tar", "v2.0"), Origin(url=origin),),
         # v3.0: loaded despite having an (extid_type, extid) in storage, because
         #       the target of the extid is not in the previous snapshot
         call(StubPackageInfo(origin, "example-v3.0.tar", "v3.0"), Origin(url=origin),),
         # v4.0: loaded, because there isn't its extid
         call(StubPackageInfo(origin, "example-v4.0.tar", "v4.0"), Origin(url=origin),),
     ]
 
     # then check the snapshot has all the branches.
     # versions 2.0 to 4.0 all point to rel4_swhid (instead of the value of the last
     # snapshot), because they had to be loaded (mismatched extid), and the mocked
     # _load_release always returns rel4_swhid.
     snapshot = Snapshot(
         branches={
             b"branch-v1.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel1_swhid.object_id
             ),
             b"branch-v2.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel4_swhid.object_id
             ),
             b"branch-v3.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel4_swhid.object_id
             ),
             b"branch-v4.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel4_swhid.object_id
             ),
         }
     )
     assert snapshot_get_latest(storage, origin) == snapshot
 
     extids = storage.extid_get_from_target(
         ObjectType.RELEASE,
         [
             rel1_swhid.object_id,
             rel2_swhid.object_id,
             rel3_swhid.object_id,
             rel4_swhid.object_id,
         ],
     )
 
     assert set(extids) == {
         # What we inserted at the beginning of the test:
         ExtID("extid-type1", b"extid-of-v1.0", rel1_swhid),
         ExtID("extid-type2", b"extid-of-v2.0", rel2_swhid),
         # Added by the loader:
         ExtID("extid-type1", b"extid-of-v2.0", rel4_swhid),
         ExtID("extid-type2", b"extid-of-v3.0", rel4_swhid),
         ExtID("extid-type2", b"extid-of-v4.0", rel4_swhid),
     }
 
 
 def test_load_upgrade_from_revision_extids(caplog):
     """Tests that, when loading incrementally based on a snapshot made by an old
     version of the loader, the loader will convert revisions to releases
     and add them to the storage.
 
     Also checks that, if an extid exists pointing to a non-existent revision
     (which should never happen, but you never know...), the release is loaded from
     scratch."""
 
     storage = get_storage("memory")
 
     origin = "http://example.org"
     dir1_swhid = CoreSWHID(object_type=ObjectType.DIRECTORY, object_id=b"d" * 20)
     dir2_swhid = CoreSWHID(object_type=ObjectType.DIRECTORY, object_id=b"e" * 20)
 
     date = TimestampWithTimezone.from_datetime(
         datetime.datetime.now(tz=datetime.timezone.utc)
     )
     person = Person.from_fullname(b"Jane Doe <jdoe@example.org>")
 
     rev1 = Revision(
         message=b"blah",
         author=person,
         date=date,
         committer=person,
         committer_date=date,
         directory=dir1_swhid.object_id,
         type=RevisionType.TAR,
         synthetic=True,
     )
 
     rel1 = Release(
         name=b"v1.0",
         message=b"blah\n",
         author=person,
         date=date,
         target=dir1_swhid.object_id,
         target_type=ModelObjectType.DIRECTORY,
         synthetic=True,
     )
 
     rev1_swhid = rev1.swhid()
     rel1_swhid = rel1.swhid()
     rev2_swhid = CoreSWHID(object_type=ObjectType.REVISION, object_id=b"b" * 20)
     rel2_swhid = CoreSWHID(object_type=ObjectType.RELEASE, object_id=b"c" * 20)
 
     # Results of a previous load
     storage.extid_add(
         [
-            ExtID("extid-type1", b"extid-of-v1.0", rev1_swhid),
-            ExtID("extid-type1", b"extid-of-v2.0", rev2_swhid),
+            ExtID("extid-type1", b"extid-of-v1.0", rev1_swhid, 0),
+            ExtID("extid-type1", b"extid-of-v2.0", rev2_swhid, 0),
         ]
     )
     storage.revision_add([rev1])
     last_snapshot = Snapshot(
         branches={
             b"v1.0": SnapshotBranch(
                 target_type=TargetType.REVISION, target=rev1_swhid.object_id
             ),
             b"v2.0": SnapshotBranch(
                 target_type=TargetType.REVISION, target=rev2_swhid.object_id
             ),
         }
     )
     storage.snapshot_add([last_snapshot])
     date = datetime.datetime.now(tz=datetime.timezone.utc)
     storage.origin_add([Origin(url=origin)])
     storage.origin_visit_add(
         [OriginVisit(origin="http://example.org", visit=1, date=date, type="tar")]
     )
     storage.origin_visit_status_add(
         [
             OriginVisitStatus(
                 origin=origin,
                 visit=1,
                 status="full",
                 date=date,
                 snapshot=last_snapshot.id,
             )
         ]
     )
 
     loader = StubPackageLoader(storage, "http://example.org")
     patch.object(
         loader,
         "_load_release",
         return_value=(rel2_swhid.object_id, dir2_swhid.object_id),
         autospec=True,
     ).start()
     patch.object(
         loader, "get_versions", return_value=["v1.0", "v2.0", "v3.0"], autospec=True,
     ).start()
 
     caplog.set_level(logging.ERROR)
 
     loader.load()
 
     assert len(caplog.records) == 1
     (record,) = caplog.records
     assert record.levelname == "ERROR"
     assert "Failed to upgrade branch branch-v2.0" in record.message
 
     assert loader._load_release.mock_calls == [
         # v1.0: not loaded because there is already a revision matching it
         # v2.0: loaded, as the revision is missing from the storage even though there
         #       is an extid
         call(StubPackageInfo(origin, "example-v2.0.tar", "v2.0"), Origin(url=origin)),
         # v3.0: loaded (did not exist yet)
         call(StubPackageInfo(origin, "example-v3.0.tar", "v3.0"), Origin(url=origin)),
     ]
 
     snapshot = Snapshot(
         branches={
             b"branch-v1.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel1_swhid.object_id
             ),
             b"branch-v2.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel2_swhid.object_id
             ),
             b"branch-v3.0": SnapshotBranch(
                 target_type=TargetType.RELEASE, target=rel2_swhid.object_id
             ),
         }
     )
     assert snapshot_get_latest(storage, origin) == snapshot
 
     extids = storage.extid_get_from_target(
         ObjectType.RELEASE, [rel1_swhid.object_id, rel2_swhid.object_id,],
     )
 
     assert set(extids) == {
         ExtID("extid-type1", b"extid-of-v1.0", rel1_swhid),
         ExtID("extid-type1", b"extid-of-v2.0", rel2_swhid),
         ExtID("extid-type2", b"extid-of-v3.0", rel2_swhid),
     }
 
 
 def test_manifest_extid():
     """Compute primary key should return the right identity
 
     """
 
     @attr.s
     class TestPackageInfo(BasePackageInfo):
         a = attr.ib()
         b = attr.ib()
         length = attr.ib()
         filename = attr.ib()
 
         MANIFEST_FORMAT = string.Template("$a $b")
 
     p_info = TestPackageInfo(
         url="http://example.org/",
         a=1,
         b=2,
         length=221837,
         filename="8sync-0.1.0.tar.gz",
         version="0.1.0",
     )
 
     actual_id = p_info.extid()
-    assert actual_id == ("package-manifest-sha256", hashlib.sha256(b"1 2").digest())
+    assert actual_id == ("package-manifest-sha256", 0, hashlib.sha256(b"1 2").digest())
 
 
 def test_no_env_swh_config_filename_raise(monkeypatch):
     """No SWH_CONFIG_FILENAME environment variable makes package loader init raise
 
     """
 
     class DummyPackageLoader(PackageLoader):
         """A dummy package loader for test purpose"""
 
         pass
 
     monkeypatch.delenv("SWH_CONFIG_FILENAME", raising=False)
 
     with pytest.raises(
         AssertionError, match="SWH_CONFIG_FILENAME environment variable is undefined"
     ):
         DummyPackageLoader.from_configfile(url="some-url")