def _containment_rel(self, create, ignore_type=True):
"""Find the closest parent in the path indicated by the uid and
establish a containment triple.
Check the path-wise parent of the new resource. If it exists, add the
containment relationship with this UID. Otherwise, create a container
resource as the parent.
This function may recurse up the path tree until an existing container
is found.
E.g. if only fcres:/a exists:
- If ``fcres:/a/b/c/d`` is being created, a becomes container of
``fcres:/a/b/c/d``. Also, containers are created for fcres:a/b and
``fcres:/a/b/c``.
- If ``fcres:/e`` is being created, the root node becomes container of
``fcres:/e``.
:param bool create: Whether the resource is being created. If false,
the parent container is not updated.
"param bool ignore_type: If False (the default), an exception is raised
if trying to create a resource under a non-container. This can be
overridden in special cases (e.g. when migrating a repository in which
a LDP-NR has "children" under ``fcr:versions``) by setting this to
True.
"""
from lakesuperior.model.ldp.ldp_factory import LdpFactory
if '/' in self.uid.lstrip('/'):
# Traverse up the hierarchy to find the parent.
path_components = self.uid.lstrip('/').split('/')
cnd_parent_uid = '/' + '/'.join(path_components[:-1])
if rdfly.ask_rsrc_exists(cnd_parent_uid):
parent_rsrc = LdpFactory.from_stored(cnd_parent_uid)
if (not ignore_type
and nsc['ldp'].Container not in parent_rsrc.types):
raise InvalidResourceError(
cnd_parent_uid, 'Parent {} is not a container.')
parent_uid = cnd_parent_uid
else:
parent_rsrc = LdpFactory.new_container(cnd_parent_uid)
# This will trigger this method again and recurse until an
# existing container or the root node is reached.
parent_rsrc.create_or_replace()
parent_uid = parent_rsrc.uid
else:
parent_uid = ROOT_UID
parent_rsrc = LdpFactory.from_stored(
parent_uid, repr_opts={'incl_children': False}, handling='none')
# Only update parent if the resource is new.
if create:
add_gr = Graph()
add_gr.add({(nsc['fcres'][parent_uid], nsc['ldp'].contains,
self.uri)})
parent_rsrc.modify(RES_UPDATED, add_trp=add_gr)
# Direct or indirect container relationship.
return self._add_ldp_dc_ic_rel(parent_rsrc)
def create_or_replace(uid, stream=None, **kwargs):
'''
Create or replace a resource with a specified UID.
If the resource already exists, all user-provided properties of the
existing resource are deleted. If the resource exists and the provided
content is empty, an exception is raised (not sure why, but that's how
FCREPO4 handles it).
@param uid (string) UID of the resource to be created or updated.
@param stream (BytesIO) Content stream. If empty, an empty container is
created.
@param **kwargs Other parameters are passed to the
LdpFactory.from_provided method. Please see the documentation for that
method for explanation of individual parameters.
@return string Event type: whether the resource was created or updated.
'''
rsrc = LdpFactory.from_provided(uid, stream=stream, **kwargs)
if not stream and rsrc.is_stored:
raise InvalidResourceError(
rsrc.uid,
'Resource {} already exists and no data set was provided.')
return rsrc.create_or_replace_rsrc()
def new_container(uid):
if not uid.startswith('/') or uid == '/':
raise InvalidResourceError(uid)
if rdfly.ask_rsrc_exists(uid):
raise ResourceExistsError(uid)
rsrc = Ldpc(uid, provided_imr=Resource(Graph(), nsc['fcres'][uid]))
return rsrc
def snapshot_uid(self, uid, ver_uid):
"""
Create a versioned UID string from a main UID and a version UID.
"""
if VERS_CONT_LABEL in uid:
raise InvalidResourceError(
uid, 'Resource \'{}\' is already a version.')
return '{}/{}/{}'.format(uid, VERS_CONT_LABEL, ver_uid)
def _containment_rel(self, create):
'''Find the closest parent in the path indicated by the uid and
establish a containment triple.
Check the path-wise parent of the new resource. If it exists, add the
containment relationship with this UID. Otherwise, create a container
resource as the parent.
This function may recurse up the path tree until an existing container
is found.
E.g. if only fcres:/a exists:
- If fcres:/a/b/c/d is being created, a becomes container of
fcres:/a/b/c/d. Also, containers are created for fcres:a/b and
fcres:/a/b/c.
- If fcres:/e is being created, the root node becomes container of
fcres:/e.
@param create (bool) Whether the resource is being created. If false,
the parent container is not updated.
'''
from lakesuperior.model.ldp_factory import LdpFactory
if '/' in self.uid.lstrip('/'):
# Traverse up the hierarchy to find the parent.
path_components = self.uid.lstrip('/').split('/')
cnd_parent_uid = '/' + '/'.join(path_components[:-1])
if rdfly.ask_rsrc_exists(cnd_parent_uid):
parent_rsrc = LdpFactory.from_stored(cnd_parent_uid)
if nsc['ldp'].Container not in parent_rsrc.types:
raise InvalidResourceError(
cnd_parent_uid, 'Parent {} is not a container.')
parent_uid = cnd_parent_uid
else:
parent_rsrc = LdpFactory.new_container(cnd_parent_uid)
# This will trigger this method again and recurse until an
# existing container or the root node is reached.
parent_rsrc.create_or_replace()
parent_uid = parent_rsrc.uid
else:
parent_uid = ROOT_UID
parent_rsrc = LdpFactory.from_stored(
parent_uid, repr_opts={'incl_children': False}, handling='none')
# Only update parent if the resource is new.
if create:
add_gr = Graph()
add_gr.add(
(nsc['fcres'][parent_uid], nsc['ldp'].contains, self.uri))
parent_rsrc._modify_rsrc(RES_UPDATED, add_trp=add_gr)
# Direct or indirect container relationship.
return self._add_ldp_dc_ic_rel(parent_rsrc)
def resurrect(uid):
"""
Reinstate a buried (soft-deleted) resource.
:param str uid: Resource UID.
"""
try:
rsrc = LdpFactory.from_stored(uid)
except TombstoneError as e:
if e.uid != uid:
raise
else:
return LdpFactory.from_stored(uid, strict=False).resurrect()
else:
raise InvalidResourceError(uid,
msg='Resource {} is not dead.'.format(uid))
def mint_uid(parent_uid, path=None):
"""
Mint a new resource UID based on client directives.
This method takes a parent ID and a tentative path and returns an LDP
resource UID.
This may raise an exception resulting in a 404 if the parent is not
found or a 409 if the parent is not a valid container.
:param str parent_uid: UID of the parent resource. It must be an
existing LDPC.
:param str path: path to the resource, relative to the parent.
:rtype: str
:return: The confirmed resource UID. This may be different from
what has been indicated.
"""
def split_if_legacy(uid):
if config['application']['store']['ldp_rs']['legacy_ptree_split']:
uid = tbox.split_uuid(uid)
return uid
if path and path.startswith('/'):
raise ValueError('Slug cannot start with a slash.')
# Shortcut!
if not path and parent_uid == '/':
return '/' + split_if_legacy(str(uuid4()))
if not parent_uid.startswith('/'):
raise ValueError('Invalid parent UID: {}'.format(parent_uid))
parent = LdpFactory.from_stored(parent_uid)
if nsc['ldp'].Container not in parent.types:
raise InvalidResourceError(parent_uid,
'Parent {} is not a container.')
pfx = parent_uid.rstrip('/') + '/'
if path:
cnd_uid = pfx + path
if not rdfly.ask_rsrc_exists(cnd_uid):
return cnd_uid
return pfx + split_if_legacy(str(uuid4()))
def update(uid, update_str, is_metadata=False):
'''
Update a resource with a SPARQL-Update string.
@param uid (string) Resource UID.
@param update_str (string) SPARQL-Update statements.
@param is_metadata (bool) Whether the resource metadata is being updated.
If False, and the resource being updated is a LDP-NR, an error is raised.
'''
rsrc = LdpFactory.from_stored(uid)
if LDP_NR_TYPE in rsrc.ldp_types:
if is_metadata:
rsrc.patch_metadata(update_str)
else:
raise InvalidResourceError(uid)
else:
rsrc.patch(update_str)
return rsrc
def update(uid, update_str, is_metadata=False):
"""
Update a resource with a SPARQL-Update string.
:param string uid: Resource UID.
:param string update_str: SPARQL-Update statements.
:param bool is_metadata: Whether the resource metadata are being updated.
:raise InvalidResourceError: If ``is_metadata`` is False and the resource
being updated is a LDP-NR.
"""
# FCREPO is lenient here and Hyrax requires it.
rsrc = LdpFactory.from_stored(uid, handling='lenient')
if LDP_NR_TYPE in rsrc.ldp_types and not is_metadata:
raise InvalidResourceError(
'Cannot use this method to update an LDP-NR content.')
delta = rsrc.sparql_delta(update_str)
rsrc.modify(RES_UPDATED, *delta)
return rsrc
def update(uid, update_str, is_metadata=False, handling='strict'):
"""
Update a resource with a SPARQL-Update string.
:param string uid: Resource UID.
:param string update_str: SPARQL-Update statements.
:param bool is_metadata: Whether the resource metadata are being updated.
:param str handling: How to handle server-managed triples. ``strict``
(the default) rejects the update with an exception if server-managed
triples are being changed. ``lenient`` modifies the update graph so
offending triples are removed and the update can be applied.
:raise InvalidResourceError: If ``is_metadata`` is False and the resource
being updated is a LDP-NR.
"""
rsrc = LdpFactory.from_stored(uid, handling=handling)
if LDP_NR_TYPE in rsrc.ldp_types and not is_metadata:
raise InvalidResourceError(
'Cannot use this method to update an LDP-NR content.')
delta = rsrc.sparql_delta(update_str)
rsrc.modify(RES_UPDATED, *delta)
return rsrc