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):
# 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):
data.pop("type")
return FileManifest(**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):
# 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):
data.pop("type")
return WorkspaceManifest(**data)
class SCHEMA_CLS(BaseSchema):
name = EntryNameField(validate=validate.Length(min=1, max=256),
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):
return WorkspaceEntry(**data)
class RealmStartReencryptionMaintenanceReqSchema(BaseReqSchema):
realm_id = fields.UUID(required=True)
encryption_revision = fields.Integer(required=True)
timestamp = fields.DateTime(required=True)
per_participant_message = fields.Map(UserIDField(),
fields.Bytes(required=True),
required=True)
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)
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):
# 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):
data.pop("type")
return UserManifest(**data)
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(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.EnumCheckedConstant(MessageContentType.SHARING_GRANTED,
required=True)
name = fields.String(required=True)
author = DeviceIDField(required=True, allow_none=False)
id = EntryIDField(required=True)
encryption_revision = fields.Integer(required=True)
encrypted_on = fields.DateTime(required=True)
key = fields.SecretKey(required=True)
# Don't include role given the only reliable way to get this information
# is to fetch the realm role certificate from the backend.
# Besides, we will also need the message sender's realm role certificate
# to make sure he is an owner.
@post_load
def make_obj(self, data):
data.pop("type")
return SharingGrantedMessageContent(**data)
class SCHEMA_CLS(BaseSchema):
type = fields.EnumCheckedConstant(
LocalManifestType.LOCAL_FOLDER_MANIFEST, required=True)
base = fields.Nested(RemoteFolderManifest.SCHEMA_CLS, required=True)
need_sync = fields.Boolean(required=True)
updated = fields.DateTime(required=True)
children = fields.FrozenMap(EntryNameField(),
EntryIDField(required=True),
required=True)
confined_entries = fields.FrozenSet(EntryIDField(required=True))
filtered_entries = fields.FrozenSet(EntryIDField(required=True))
@post_load
def make_obj(self, data):
data.pop("type")
data.setdefault("confined_entries", frozenset())
data.setdefault("filtered_entries", frozenset())
return LocalFolderManifest(**data)
class SCHEMA_CLS(OneOfSchema, BaseSchema):
type_field = "type"
base = fields.Nested(BaseRemoteManifest.SCHEMA_CLS, required=True)
need_sync = fields.Boolean(required=True)
updated = fields.DateTime(required=True)
@property
def type_schemas(self):
return {
LocalManifestType.LOCAL_FILE_MANIFEST:
LocalFileManifest.SCHEMA_CLS,
LocalManifestType.LOCAL_FOLDER_MANIFEST:
LocalFolderManifest.SCHEMA_CLS,
LocalManifestType.LOCAL_WORKSPACE_MANIFEST:
LocalWorkspaceManifest.SCHEMA_CLS,
LocalManifestType.LOCAL_USER_MANIFEST:
LocalUserManifest.SCHEMA_CLS,
}
def get_obj_type(self, obj):
return obj["type"]
class RealmStatusRepSchema(BaseRepSchema):
in_maintenance = fields.Boolean(required=True)
maintenance_type = MaintenanceTypeField(allow_none=True)
maintenance_started_on = fields.DateTime(required=True, allow_none=True)
maintenance_started_by = DeviceIDField(required=True, allow_none=True)
encryption_revision = fields.Integer(required=True)
class APIV1_OrganizationCreateRepSchema(BaseRepSchema):
bootstrap_token = fields.String(required=True)
expiration_date = fields.DateTime(allow_none=True, required=False)
class APIV1_OrganizationCreateReqSchema(BaseReqSchema):
organization_id = OrganizationIDField(required=True)
expiration_date = fields.DateTime(allow_none=True, required=False)
class MessageSchema(BaseSchema):
count = fields.Integer(required=True)
sender = DeviceIDField(required=True)
timestamp = fields.DateTime(required=True)
body = fields.Bytes(required=True)
class BaseSignedDataSchema(BaseSchema):
author = DeviceIDField(required=True, allow_none=False)
timestamp = fields.DateTime(required=True)
class InviteListItemDeviceSchema(BaseSchema):
type = fields.EnumCheckedConstant(InvitationType.DEVICE, required=True)
token = fields.UUID(required=True)
created_on = fields.DateTime(required=True)
status = InvitationStatusField(required=True)
class VlobUpdateReqSchema(BaseReqSchema):
encryption_revision = fields.Integer(required=True)
vlob_id = fields.UUID(required=True)
timestamp = fields.DateTime(required=True)
version = fields.Integer(required=True, validate=_validate_version)
blob = fields.Bytes(required=True)
class VlobReadReqSchema(BaseReqSchema):
encryption_revision = fields.Integer(required=True)
vlob_id = fields.UUID(required=True)
version = fields.Integer(validate=lambda n: n is None or _validate_version(n), missing=None)
timestamp = fields.DateTime(allow_none=True, missing=None)
class APIV1_OrganizationStatusRepSchema(BaseRepSchema):
is_bootstrapped = fields.Boolean(required=True)
expiration_date = fields.DateTime(allow_none=True, required=False)
class VlobReadRepSchema(BaseRepSchema):
version = fields.Integer(required=True, validate=_validate_version)
blob = fields.Bytes(required=True)
author = DeviceIDField(required=True)
timestamp = fields.DateTime(required=True)
class RealmGetRoleCertificatesReqSchema(BaseReqSchema):
realm_id = fields.UUID(required=True)
since = fields.DateTime(missing=None)
class VlobListVersionsRepSchema(BaseRepSchema):
versions = fields.Map(
fields.Integer(required=True),
fields.Tuple(fields.DateTime(required=True), DeviceIDField(required=True)),
required=True,
)
class InviteListItemUserSchema(BaseSchema):
type = fields.EnumCheckedConstant(InvitationType.USER, required=True)
token = fields.UUID(required=True)
created_on = fields.DateTime(required=True)
claimer_email = fields.String(required=True)
status = InvitationStatusField(required=True)
