class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.EnumCheckedConstant(ManifestType.FILE_MANIFEST,
required=True)
id = EntryIDField(required=True)
parent = EntryIDField(required=True)
# Version 0 means the data is not synchronized
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
size = fields.Integer(required=True, validate=validate.Range(min=0))
blocksize = fields.Integer(required=True,
validate=validate.Range(min=8))
blocks = fields.FrozenList(fields.Nested(BlockAccess.SCHEMA_CLS),
required=True)
@pre_load
def fix_legacy(self, data: Dict[str, T]) -> Dict[str, T]:
# Compatibility with versions <= 1.14
if data["author"] is None:
data["author"] = LOCAL_AUTHOR_LEGACY_PLACEHOLDER
return data
@post_load
def make_obj(self, data: Dict[str, Any]) -> "FileManifest":
data.pop("type")
return FileManifest(**data)
class SCHEMA_CLS(BaseSchema):
id = BlockIDField(required=True)
key = fields.SecretKey(required=True)
offset = fields.Integer(required=True, validate=validate.Range(min=0))
size = fields.Integer(required=True, validate=validate.Range(min=0))
digest = fields.HashDigest(required=True)
@post_load
def make_obj(self, data: Dict[str, Any]) -> "BlockAccess":
return BlockAccess(**data)
class SCHEMA_CLS(BaseSchema):
id = ChunkIDField(required=True)
start = fields.Integer(required=True, validate=validate.Range(min=0))
stop = fields.Integer(required=True, validate=validate.Range(min=1))
raw_offset = fields.Integer(required=True,
validate=validate.Range(min=0))
raw_size = fields.Integer(required=True,
validate=validate.Range(min=1))
access = fields.Nested(BlockAccess.SCHEMA_CLS,
required=True,
allow_none=True)
@post_load
def make_obj(self, data):
return Chunk(**data)
class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.EnumCheckedConstant(ManifestType.WORKSPACE_MANIFEST,
required=True)
id = EntryIDField(required=True)
# Version 0 means the data is not synchronized
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
children = fields.FrozenMap(
EntryNameField(validate=validate.Length(min=1, max=256)),
EntryIDField(required=True),
required=True,
)
@pre_load
def fix_legacy(self, data: Dict[str, T]) -> Dict[str, T]:
# Compatibility with versions <= 1.14
if data["author"] is None:
data["author"] = LOCAL_AUTHOR_LEGACY_PLACEHOLDER
return data
@post_load
def make_obj(self, data: Dict[str, Any]) -> "WorkspaceManifest":
data.pop("type")
return WorkspaceManifest(**data)
class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.CheckedConstant("user_manifest", required=True)
id = EntryIDField(required=True)
# Version 0 means the data is not synchronized (hence author sould be None)
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
last_processed_message = fields.Integer(required=True,
validate=validate.Range(min=0))
workspaces = fields.List(fields.Nested(WorkspaceEntry.SCHEMA_CLS),
required=True)
@post_load
def make_obj(self, data):
data.pop("type")
return UserManifest(**data)
class SCHEMA_CLS(BaseSchema):
type = fields.EnumCheckedConstant(
LocalManifestType.LOCAL_FILE_MANIFEST, required=True)
base = fields.Nested(RemoteFileManifest.SCHEMA_CLS, required=True)
need_sync = fields.Boolean(required=True)
updated = fields.DateTime(required=True)
size = fields.Integer(required=True, validate=validate.Range(min=0))
blocksize = fields.Integer(required=True,
validate=validate.Range(min=8))
blocks = fields.FrozenList(fields.FrozenList(
fields.Nested(Chunk.SCHEMA_CLS)),
required=True)
@post_load
def make_obj(self, data):
data.pop("type")
return LocalFileManifest(**data)
class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.CheckedConstant("file_manifest", required=True)
id = EntryIDField(required=True)
parent = EntryIDField(required=True)
# Version 0 means the data is not synchronized (hence author sould be None)
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
size = fields.Integer(required=True, validate=validate.Range(min=0))
blocksize = fields.Integer(required=True,
validate=validate.Range(min=8))
blocks = fields.FrozenList(fields.Nested(BlockAccess.SCHEMA_CLS),
required=True)
@post_load
def make_obj(self, data):
data.pop("type")
return FileManifest(**data)
class SCHEMA_CLS(BaseSchema):
name = EntryNameField(required=True)
id = EntryIDField(required=True)
key = fields.SecretKey(required=True)
encryption_revision = fields.Int(required=True,
validate=validate.Range(min=0))
encrypted_on = fields.DateTime(required=True)
role_cached_on = fields.DateTime(required=True)
role = RealmRoleField(required=True, allow_none=True)
@post_load
def make_obj(self, data: Dict[str, Any]) -> "WorkspaceEntry":
return WorkspaceEntry(**data)
class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.EnumCheckedConstant(ManifestType.USER_MANIFEST,
required=True)
id = EntryIDField(required=True)
# Version 0 means the data is not synchronized
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
last_processed_message = fields.Integer(required=True,
validate=validate.Range(min=0))
workspaces = fields.List(fields.Nested(WorkspaceEntry.SCHEMA_CLS),
required=True)
@pre_load
def fix_legacy(self, data: Dict[str, T]) -> Dict[str, T]:
# Compatibility with versions <= 1.14
if data["author"] is None:
data["author"] = LOCAL_AUTHOR_LEGACY_PLACEHOLDER
return data
@post_load
def make_obj(self, data: Dict[str, Any]) -> "UserManifest":
data.pop("type")
return UserManifest(**data)
class SCHEMA_CLS(OneOfSchema, BaseSignedDataSchema):
type_field = "type"
version = fields.Integer(required=True, validate=validate.Range(min=0))
@property
def type_schemas(self):
return {
ManifestType.FILE_MANIFEST: FileManifest.SCHEMA_CLS,
ManifestType.FOLDER_MANIFEST: FolderManifest.SCHEMA_CLS,
ManifestType.WORKSPACE_MANIFEST: WorkspaceManifest.SCHEMA_CLS,
ManifestType.USER_MANIFEST: UserManifest.SCHEMA_CLS,
}
def get_obj_type(self, obj):
return obj["type"]
class SCHEMA_CLS(BaseSchema):
type = fields.EnumCheckedConstant(
LocalManifestType.LOCAL_USER_MANIFEST, required=True)
base = fields.Nested(RemoteUserManifest.SCHEMA_CLS, required=True)
need_sync = fields.Boolean(required=True)
updated = fields.DateTime(required=True)
last_processed_message = fields.Integer(required=True,
validate=validate.Range(min=0))
workspaces = fields.FrozenList(fields.Nested(
WorkspaceEntry.SCHEMA_CLS),
required=True)
@post_load
def make_obj(self, data):
data.pop("type")
return LocalUserManifest(**data)
class SCHEMA_CLS(BaseSignedDataSchema):
type = fields.CheckedConstant("workspace_manifest", required=True)
id = EntryIDField(required=True)
# Version 0 means the data is not synchronized (hence author sould be None)
version = fields.Integer(required=True, validate=validate.Range(min=0))
created = fields.DateTime(required=True)
updated = fields.DateTime(required=True)
children = fields.FrozenMap(
EntryNameField(validate=validate.Length(min=1, max=256)),
EntryIDField(required=True),
required=True,
)
@post_load
def make_obj(self, data):
data.pop("type")
return WorkspaceManifest(**data)
class SCHEMA_CLS(OneOfSchema, BaseSignedDataSchema):
type_field = "type"
version = fields.Integer(required=True, validate=validate.Range(min=0))
id = EntryIDField(required=True)
@property
def type_schemas(
self
) -> Dict[ManifestType, Type[OneOfSchema]]: # type: ignore[override]
return {
ManifestType.FILE_MANIFEST: FileManifest.SCHEMA_CLS,
ManifestType.FOLDER_MANIFEST: FolderManifest.SCHEMA_CLS,
ManifestType.WORKSPACE_MANIFEST: WorkspaceManifest.SCHEMA_CLS,
ManifestType.USER_MANIFEST: UserManifest.SCHEMA_CLS,
}
def get_obj_type(self, obj: Dict[str, T]) -> T:
return obj["type"]
class SCHEMA_CLS(BaseSchema):
type = fields.EnumCheckedConstant(
LocalManifestType.LOCAL_USER_MANIFEST, required=True)
base = fields.Nested(_PyUserManifest.SCHEMA_CLS, required=True)
need_sync = fields.Boolean(required=True)
updated = fields.DateTime(required=True)
last_processed_message = fields.Integer(required=True,
validate=validate.Range(min=0))
workspaces = fields.FrozenList(fields.Nested(
_PyWorkspaceEntry.SCHEMA_CLS),
required=True)
# Added in Parsec v1.15
# Speculative placeholders are created when we want to access the
# user manifest but didn't retrieve it from backend yet. This implies:
# - non-placeholders cannot be speculative
# - the only non-speculative placeholder is the placeholder initialized
# during the initial user claim (by opposition of subsequent device
# claims on the same user)
# This speculative information is useful during merge to understand if
# a data is not present in the placeholder compared with a remote because:
# a) the data is not locally known (speculative is True)
# b) the data is known, but has been locally removed (speculative is False)
# Prevented to be `required=True` by backward compatibility
speculative = fields.Boolean(allow_none=False,
required=False,
missing=False)
@post_load
def make_obj(self, data):
data.pop("type")
# TODO: Ensure non-placeholder cannot be marked speculative
assert data["speculative"] is False or data["base"].version == 0
# TODO: Should this assert be in remote workspace manifest definition instead ?
# TODO: but in theory remote workspace manifest should assert version > 0 !
assert data["base"].version != 0 or not data["base"].workspaces
return LocalUserManifest(**data)
class CheckEntrySchema(UnknownCheckedSchema):
id = fields.UUID(required=True)
rts = fields.String(required=True, validate=_validate_trust_seed)
version = fields.Integer(required=True, validate=validate.Range(min=0))
from parsec.api.protocol.base import BaseReqSchema, BaseRepSchema, CmdSerializer
from parsec.api.protocol.types import DeviceIDField
__all__ = (
"vlob_create_serializer",
"vlob_read_serializer",
"vlob_update_serializer",
"vlob_poll_changes_serializer",
"vlob_list_versions_serializer",
"vlob_maintenance_get_reencryption_batch_serializer",
"vlob_maintenance_save_reencryption_batch_serializer",
)
_validate_version = validate.Range(min=1)
class VlobCreateReqSchema(BaseReqSchema):
realm_id = fields.UUID(required=True)
encryption_revision = fields.Integer(required=True)
vlob_id = fields.UUID(required=True)
# If blob contains a signed message, it timestamp cannot be directly enforced
# by the backend (given the message is probably also encrypted).
# Hence the timestamp is passed in clear so backend can reject the message
# if it considers the timestamp invalid. On top of that each client asking
# for the message will receive the declared timestamp to check against
# the actual timestamp within the message.
timestamp = fields.DateTime(required=True)
blob = fields.Bytes(required=True)
def __init__(self, **kwargs: object):
version = fields.Integer(required=True, validate=validate.Range(min=0))
revision = fields.Integer(required=True,
validate=validate.Range(min=0))
super().__init__(version, revision, **kwargs)
class VlobMaintenanceGetReencryptionBatchReqSchema(BaseReqSchema):
realm_id = fields.UUID(required=True)
encryption_revision = fields.Integer(required=True)
size = fields.Integer(required=True, validate=validate.Range(min=0, max=1000))
class ReencryptionBatchEntrySchema(BaseSchema):
vlob_id = fields.UUID(required=True)
version = fields.Integer(required=True, validate=validate.Range(min=0))
blob = fields.Bytes(required=True)
