diff --git a/swh/graphql/errors/__init__.py b/swh/graphql/errors/__init__.py
--- a/swh/graphql/errors/__init__.py
+++ b/swh/graphql/errors/__init__.py
@@ -4,6 +4,7 @@
# See top-level LICENSE file for more information
from .errors import (
+ DataError,
InvalidInputError,
NullableObjectError,
ObjectNotFoundError,
@@ -16,5 +17,6 @@
"PaginationError",
"InvalidInputError",
"NullableObjectError",
+ "DataError",
"format_error",
]
diff --git a/swh/graphql/errors/errors.py b/swh/graphql/errors/errors.py
--- a/swh/graphql/errors/errors.py
+++ b/swh/graphql/errors/errors.py
@@ -33,3 +33,7 @@
class NullableObjectError(Exception):
pass
+
+
+class DataError(Exception):
+ pass
diff --git a/swh/graphql/resolvers/base_connection.py b/swh/graphql/resolvers/base_connection.py
--- a/swh/graphql/resolvers/base_connection.py
+++ b/swh/graphql/resolvers/base_connection.py
@@ -157,6 +157,7 @@
self.obj: Optional[BaseNode] = obj
self.info: GraphQLResolveInfo = info
self.kwargs = kwargs
+
self._results: List = results
self.archive = Archive()
diff --git a/swh/graphql/resolvers/content.py b/swh/graphql/resolvers/content.py
--- a/swh/graphql/resolvers/content.py
+++ b/swh/graphql/resolvers/content.py
@@ -5,9 +5,10 @@
from typing import Union
-from swh.graphql.errors import InvalidInputError
+from swh.graphql.errors import DataError, InvalidInputError
from swh.model import hashutil
+from .base_connection import BaseList
from .base_node import BaseSWHNode
from .directory_entry import BaseDirectoryEntryNode
from .release import BaseReleaseNode
@@ -15,16 +16,24 @@
from .snapshot_branch import BaseSnapshotBranchNode
+def read_and_validate_content_hashes(hashes):
+ try:
+ hashes = {
+ hash_type: hashutil.hash_to_bytes(hash_value)
+ for (hash_type, hash_value) in hashes
+ }
+ except ValueError as e:
+ # raise an input error in case of an invalid hash
+ raise InvalidInputError("Invalid content hash", e)
+ else:
+ return hashes
+
+
class BaseContentNode(BaseSWHNode):
"""
Base resolver for all the content nodes
"""
- def _get_content_by_hashes(self, hashes: dict):
- content = self.archive.get_contents(hashes)
- # in case of a conflict, return the first element
- return content[0] if content else None
-
@property
def hashes(self):
# FIXME, use a Node instead
@@ -65,33 +74,19 @@
return "Content"
-class ContentNode(BaseContentNode):
- """
- Node resolver for a content requested directly with its SWHID
- """
-
- def _get_node_data(self):
- hashes = {"sha1_git": self.kwargs.get("swhid").object_id}
- return self._get_content_by_hashes(hashes)
-
-
-class HashContentNode(BaseContentNode):
+class ContentbyHashesNode(BaseContentNode):
"""
- Node resolver for a content requested with one or more hashes
+ Node resolver for a content requested with all of its hashes
+ A single content object will be returned
"""
def _get_node_data(self):
- try:
- hashes = {
- hash_type: hashutil.hash_to_bytes(hash_value)
- for (hash_type, hash_value) in self.kwargs.items()
- }
- except ValueError as e:
- # raise an input error in case of an invalid hash
- raise InvalidInputError("Invalid content hash", e)
- if not hashes:
- raise InvalidInputError("At least one of the four hashes must be provided")
- return self._get_content_by_hashes(hashes)
+ hashes = read_and_validate_content_hashes(self.kwargs.items())
+ contents = self.archive.get_contents(hashes=hashes)
+ if len(contents) > 1:
+ # This situation is not expected to happen IRL
+ raise DataError("Content hash conflict for the set ", hashes)
+ return contents[0] if contents else None
class TargetContentNode(BaseContentNode):
@@ -108,4 +103,36 @@
]
def _get_node_data(self):
- return self._get_content_by_hashes(hashes={"sha1_git": self.obj.target_hash})
+ # FIXME, this is not considering hash collisions
+ # and could return a wrong object in very rare situations
+ contents = self.archive.get_contents(hashes={"sha1_git": self.obj.target_hash})
+ # always returning the first content from the storage
+ return contents[0] if contents else None
+
+
+class ContentSwhidList(BaseList):
+ """
+ Return a non paginated list of contents for the given SWHID
+ This will return a single item in most of the cases
+ """
+
+ _node_class = BaseContentNode
+
+ def _get_results(self):
+ hashes = {"sha1_git": self.kwargs.get("swhid").object_id}
+ return self.archive.get_contents(hashes=hashes)
+
+
+class ContentHashList(BaseList):
+ """
+ Return a non paginated list of contents for the given hashes
+ This will return a single item in most of the cases
+ """
+
+ _node_class = BaseContentNode
+
+ def _get_results(self):
+ hashes = read_and_validate_content_hashes(self.kwargs.items())
+ if not hashes:
+ raise InvalidInputError("At least one of the four hashes must be provided")
+ return self.archive.get_contents(hashes=hashes)
diff --git a/swh/graphql/resolvers/resolver_factory.py b/swh/graphql/resolvers/resolver_factory.py
--- a/swh/graphql/resolvers/resolver_factory.py
+++ b/swh/graphql/resolvers/resolver_factory.py
@@ -9,7 +9,12 @@
from .base_connection import BaseConnection, BaseList
from .base_node import BaseNode
-from .content import ContentNode, HashContentNode, TargetContentNode
+from .content import (
+ ContentbyHashesNode,
+ ContentHashList,
+ ContentSwhidList,
+ TargetContentNode,
+)
from .directory import DirectoryNode, RevisionDirectoryNode, TargetDirectoryNode
from .directory_entry import DirectoryEntryConnection, DirectoryEntryNode
from .origin import OriginConnection, OriginNode, TargetOriginNode
@@ -55,8 +60,7 @@
"release-content": TargetContentNode,
"directory": DirectoryNode,
"directory-entry": DirectoryEntryNode,
- "content": ContentNode,
- "content-by-hash": HashContentNode,
+ "content-by-hashes": ContentbyHashesNode,
"dir-entry-content": TargetContentNode,
"dir-entry-directory": TargetDirectoryNode,
"dir-entry-revision": TargetRevisionNode,
@@ -105,6 +109,8 @@
class SimpleListFactory:
mapping: ClassVar[Dict[str, Type[BaseList]]] = {
"resolve-swhid": ResolveSwhidList,
+ "contents-swhid": ContentSwhidList,
+ "contents-hashes": ContentHashList,
}
@classmethod
diff --git a/swh/graphql/resolvers/resolvers.py b/swh/graphql/resolvers/resolvers.py
--- a/swh/graphql/resolvers/resolvers.py
+++ b/swh/graphql/resolvers/resolvers.py
@@ -177,13 +177,6 @@
return NodeObjectFactory.create(f"dir-entry-{obj.targetType}", obj, info, **kw)
-@query.field("content")
-def content_resolver(
- obj: None, info: GraphQLResolveInfo, **kw
-) -> rs.content.ContentNode:
- return NodeObjectFactory.create("content", obj, info, **kw)
-
-
@search_result.field("target")
def search_result_target_resolver(
obj: rs.search.SearchResultNode, info: GraphQLResolveInfo, **kw
@@ -203,10 +196,10 @@
@query.field("contentByHashes")
-def content_by_hash_resolver(
+def content_by_hashes_resolver(
obj: None, info: GraphQLResolveInfo, **kw
-) -> rs.content.ContentNode:
- return NodeObjectFactory.create("content-by-hash", obj, info, **kw)
+) -> rs.content.ContentbyHashesNode:
+ return NodeObjectFactory.create("content-by-hashes", obj, info, **kw)
# Connection resolvers
@@ -279,6 +272,20 @@
# Simple list resolvers (lists without paginations)
+@query.field("contentsBySWHID")
+def contnets_by_swhid_resolver(
+ obj: None, info: GraphQLResolveInfo, **kw
+) -> rs.content.ContentSwhidList:
+ return SimpleListFactory.create("contents-swhid", obj, info, **kw)
+
+
+@query.field("contentsByHashes")
+def contnets_by_hashes_resolver(
+ obj: None, info: GraphQLResolveInfo, **kw
+) -> rs.content.ContentHashList:
+ return SimpleListFactory.create("contents-hashes", obj, info, **kw)
+
+
@query.field("resolveSWHID")
def search_swhid_resolver(
obj: None, info: GraphQLResolveInfo, **kw
diff --git a/swh/graphql/schema/schema.graphql b/swh/graphql/schema/schema.graphql
--- a/swh/graphql/schema/schema.graphql
+++ b/swh/graphql/schema/schema.graphql
@@ -1105,24 +1105,20 @@
): DirectoryEntry
"""
- Get the content with a SWHID
+ Get a list of contents for the given SWHID
"""
- content(
+ contentsBySWHID (
"""
- SWHID of the content object
+ SWHID to look for
"""
swhid: SWHID!
- ): Content
+ ): [Content]
"""
- Get a content that match all the given hashes.
- This entrypoint can be used to uniquely identify a content
- in the event of hash conflicts. Use multiple hashes to
- get an accurate result.
-
- At least one of the four hashes must be provided.
+ Get contents with hashes
+ At least one of the four hashes must be provided
"""
- contentByHashes(
+ contentsByHashes(
sha1: String
sha256: String
@@ -1130,6 +1126,22 @@
sha1_git: String
blake2s256: String
+ ): [Content]
+
+ """
+ Get a content that match all the given hashes.
+ All the four hashes must be provided
+ This entrypoint can be used to uniquely identify
+ a content in the event of hash collisions
+ """
+ contentByHashes(
+ sha1: String!
+
+ sha256: String!
+
+ sha1_git: String!
+
+ blake2s256: String!
): Content
"""
diff --git a/swh/graphql/tests/functional/test_content.py b/swh/graphql/tests/functional/test_content.py
--- a/swh/graphql/tests/functional/test_content.py
+++ b/swh/graphql/tests/functional/test_content.py
@@ -10,10 +10,12 @@
@pytest.mark.parametrize("content", get_contents())
-def test_get_content_with_swhid(client, content):
+def test_get_content_with_hashes(client, content):
query_str = """
- query getContent($swhid: SWHID!) {
- content(swhid: $swhid) {
+ query getContentByHashes($sha1: String!, $sha256: String!,
+ $sha1_git: String!, $blake2s256: String!) {
+ contentByHashes(sha1: $sha1, sha256: $sha256, sha1_git: $sha1_git,
+ blake2s256: $blake2s256) {
swhid
id
hashes {
@@ -39,7 +41,14 @@
}
}
"""
- data, _ = utils.get_query_response(client, query_str, swhid=str(content.swhid()))
+ data, _ = utils.get_query_response(
+ client,
+ query_str,
+ blake2s256=content.blake2s256.hex(),
+ sha1=content.sha1.hex(),
+ sha1_git=content.sha1_git.hex(),
+ sha256=content.sha256.hex(),
+ )
archive_url = "https://archive.softwareheritage.org/api/1/"
response = {
"swhid": str(content.swhid()),
@@ -59,13 +68,26 @@
"language": None,
"license": None,
}
- assert data["content"] == response
+ assert data["contentByHashes"] == response
-def test_get_content_with_invalid_swhid(client):
+@pytest.mark.parametrize("content", get_contents())
+def test_get_contents_with_swhid(client, content):
query_str = """
- query getContent($swhid: SWHID!) {
- content(swhid: $swhid) {
+ query getContents($swhid: SWHID!) {
+ contentsBySWHID(swhid: $swhid) {
+ swhid
+ }
+ }
+ """
+ data, _ = utils.get_query_response(client, query_str, swhid=str(content.swhid()))
+ assert data["contentsBySWHID"] == [{"swhid": str(content.swhid())}]
+
+
+def test_get_contents_with_invalid_swhid(client):
+ query_str = """
+ query getContents($swhid: SWHID!) {
+ contentsBySWHID(swhid: $swhid) {
swhid
}
}
@@ -76,11 +98,27 @@
assert "Input error: Invalid SWHID" in errors[0]["message"]
+def test_get_contents_with_missing_swhid(client):
+ missing_sha1 = "1" * 40
+ query_str = """
+ query getContents($swhid: SWHID!) {
+ contentsBySWHID(swhid: $swhid) {
+ swhid
+ }
+ }
+ """
+ data, _ = utils.get_query_response(
+ client, query_str, swhid=f"swh:1:cnt:{missing_sha1}"
+ )
+ assert data["contentsBySWHID"] == []
+
+
@pytest.mark.parametrize("content", get_contents())
-def test_get_content_with_hash(client, content):
+def test_get_contents_with_hashes(client, content):
query_str = """
- query getContent($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
- contentByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
+ query getContents($sha1: String, $sha1_git: String, $sha256: String,
+ $blake2s256: String) {
+ contentsByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
blake2s256: $blake2s256) {
swhid
}
@@ -94,14 +132,15 @@
sha256=content.sha256.hex(),
blake2s256=content.blake2s256.hex(),
)
- assert data["contentByHashes"] == {"swhid": str(content.swhid())}
+ assert data["contentsByHashes"] == [{"swhid": str(content.swhid())}]
@pytest.mark.parametrize("content", get_contents())
def test_get_content_with_single_hash(client, content):
query_str = """
- query getContent($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
- contentByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
+ query getContents($sha1: String, $sha1_git: String, $sha256: String,
+ $blake2s256: String) {
+ contentsByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
blake2s256: $blake2s256) {
swhid
}
@@ -112,34 +151,43 @@
query_str,
sha1=content.sha1.hex(),
)
- assert data["contentByHashes"] == {"swhid": str(content.swhid())}
+ assert data["contentsByHashes"] == [{"swhid": str(content.swhid())}]
+
+ data, _ = utils.get_query_response(
+ client,
+ query_str,
+ blake2s256=content.blake2s256.hex(),
+ )
+ assert data["contentsByHashes"] == [{"swhid": str(content.swhid())}]
@pytest.mark.parametrize("content", get_contents())
-def test_get_content_with_one_non_matching_hash(client, content):
+def test_get_contents_with_one_non_matching_hash(client, content):
query_str = """
- query getContent($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
- contentByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
+ query getContents($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
+ contentsByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
blake2s256: $blake2s256) {
swhid
}
}
"""
- utils.assert_missing_object(
+ data, _ = utils.get_query_response(
client,
query_str,
- obj_type="contentByHashes",
+ obj_type="contentsByHashes",
sha1=content.sha1.hex(),
sha1_git="a" * 20, # hash is valid, but not matching the object
)
+ assert data["contentsByHashes"] == []
def test_get_content_with_invalid_hashes(client):
content = get_contents()[0]
query_str = """
- query getContent($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
- contentByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
- blake2s256: $blake2s256) {
+ query getContents($sha1: String, $sha1_git: String, $sha256: String,
+ $blake2s256: String) {
+ contentsByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
+ blake2s256: $blake2s256) {
swhid
}
}
@@ -158,8 +206,8 @@
def test_get_content_with_no_hashes(client):
query_str = """
- query getContent($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
- contentByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
+ query getContents($sha1: String, $sha1_git: String, $sha256: String, $blake2s256: String) {
+ contentsByHashes(sha1: $sha1, sha1_git: $sha1_git, sha256: $sha256,
blake2s256: $blake2s256) {
swhid
}
@@ -203,20 +251,3 @@
"length": 4,
"swhid": "swh:1:cnt:86bc6b377e9d25f9d26777a4a28d08e63e7c5779",
}
-
-
-def test_get_content_with_unknown_swhid(client):
- unknown_sha1 = "1" * 40
- query_str = """
- query getDirectory($swhid: SWHID!) {
- content(swhid: $swhid) {
- swhid
- }
- }
- """
- utils.assert_missing_object(
- client,
- query_str,
- obj_type="content",
- swhid=f"swh:1:cnt:{unknown_sha1}",
- )
diff --git a/swh/graphql/tests/unit/resolvers/test_resolver_factory.py b/swh/graphql/tests/unit/resolvers/test_resolver_factory.py
--- a/swh/graphql/tests/unit/resolvers/test_resolver_factory.py
+++ b/swh/graphql/tests/unit/resolvers/test_resolver_factory.py
@@ -17,6 +17,6 @@
with pytest.raises(AttributeError):
resolver_factory.ConnectionObjectFactory().create("invalid", None, None)
- def test_get_list_resolver_invalid_type(self):
+ def test_get_base_list_resolver_invalid_type(self):
with pytest.raises(AttributeError):
resolver_factory.SimpleListFactory().create("invalid", None, None)
diff --git a/swh/graphql/tests/unit/resolvers/test_resolvers.py b/swh/graphql/tests/unit/resolvers/test_resolvers.py
--- a/swh/graphql/tests/unit/resolvers/test_resolvers.py
+++ b/swh/graphql/tests/unit/resolvers/test_resolvers.py
@@ -31,7 +31,7 @@
(rs.revision_directory_resolver, resolvers.directory.RevisionDirectoryNode),
(rs.release_resolver, resolvers.release.ReleaseNode),
(rs.directory_resolver, resolvers.directory.DirectoryNode),
- (rs.content_resolver, resolvers.content.ContentNode),
+ (rs.content_by_hashes_resolver, resolvers.content.ContentbyHashesNode),
],
)
def test_node_resolver(self, mocker, dummy_node, resolver_func, node_cls):