nickslowinski/vaultwarden-test
1
0
Fork 0
geforkt von mirrored/vaultwarden
Code Pull-Requests Aktivität

Fixed foreign-key (mariadb) errors.

Quellcode durchsuchen 
When using MariaDB v10.5+ Foreign-Key errors were popping up because of
some changes in that version. To mitigate this on MariaDB and other
MySQL forks those errors are now catched, and instead of a replace_into
an update will happen. I have tested this as thorough as possible with
MariaDB 10.5, 10.4, 10.3 and the default MySQL on Ubuntu Focal. And
tested it again using sqlite, all seems to be ok on all tables.

resolves #1081. resolves #1065, resolves #1050
Dieser Commit ist enthalten in:
BlackDex 2020-09-22 12:13:02 +02:00
Ursprung 2f3e18caa9
Commit 978be0b4a9
8 geänderte Dateien mit 170 neuen und 45 gelöschten Zeilen
Statistiken anzeigen Patch-Datei herunterladen Diff-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

15
src/db/models/attachment.rs
Datei anzeigen

@ -63,10 +63,21 @@ impl Attachment {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(attachments::table) match diesel::replace_into(attachments::table)
.values(AttachmentDb::to_db(self)) .values(AttachmentDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving attachment") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(attachments::table)
.filter(attachments::id.eq(&self.id))
.set(AttachmentDb::to_db(self))
.execute(conn)
.map_res("Error saving attachment")
}
Err(e) => Err(e.into()),
}.map_res("Error saving attachment")
} }
postgresql { postgresql {
let value = AttachmentDb::to_db(self); let value = AttachmentDb::to_db(self);

21
src/db/models/cipher.rs
Datei anzeigen

@ -194,14 +194,25 @@ impl Cipher {
pub fn save(&mut self, conn: &DbConn) -> EmptyResult { pub fn save(&mut self, conn: &DbConn) -> EmptyResult {
self.update_users_revision(conn); self.update_users_revision(conn);
self.updated_at = Utc::now().naive_utc(); self.updated_at = Utc::now().naive_utc();
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(ciphers::table) match diesel::replace_into(ciphers::table)
.values(CipherDb::to_db(self)) .values(CipherDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving cipher") {
} Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(ciphers::table)
.filter(ciphers::uuid.eq(&self.uuid))
.set(CipherDb::to_db(self))
.execute(conn)
.map_res("Error saving cipher")
}
Err(e) => Err(e.into()),
}.map_res("Error saving cipher")
}
postgresql { postgresql {
let value = CipherDb::to_db(self); let value = CipherDb::to_db(self);
diesel::insert_into(ciphers::table) diesel::insert_into(ciphers::table)

49
src/db/models/collection.rs
Datei anzeigen

@ -67,12 +67,23 @@ impl Collection {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
self.update_users_revision(conn); self.update_users_revision(conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(collections::table) match diesel::replace_into(collections::table)
.values(CollectionDb::to_db(self)) .values(CollectionDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving collection") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(collections::table)
.filter(collections::uuid.eq(&self.uuid))
.set(CollectionDb::to_db(self))
.execute(conn)
.map_res("Error saving collection")
}
Err(e) => Err(e.into()),
}.map_res("Error saving collection")
} }
postgresql { postgresql {
let value = CollectionDb::to_db(self); let value = CollectionDb::to_db(self);
@ -82,7 +93,7 @@ impl Collection {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving collection") .map_res("Error saving collection")
} }
} }
} }
@ -245,9 +256,9 @@ impl CollectionUser {
pub fn save(user_uuid: &str, collection_uuid: &str, read_only: bool, hide_passwords: bool, conn: &DbConn) -> EmptyResult { pub fn save(user_uuid: &str, collection_uuid: &str, read_only: bool, hide_passwords: bool, conn: &DbConn) -> EmptyResult {
User::update_uuid_revision(&user_uuid, conn); User::update_uuid_revision(&user_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users_collections::table) match diesel::replace_into(users_collections::table)
.values(( .values((
users_collections::user_uuid.eq(user_uuid), users_collections::user_uuid.eq(user_uuid),
users_collections::collection_uuid.eq(collection_uuid), users_collections::collection_uuid.eq(collection_uuid),
@ -255,7 +266,24 @@ impl CollectionUser {
users_collections::hide_passwords.eq(hide_passwords), users_collections::hide_passwords.eq(hide_passwords),
)) ))
.execute(conn) .execute(conn)
.map_res("Error adding user to collection") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users_collections::table)
.filter(users_collections::user_uuid.eq(user_uuid))
.filter(users_collections::collection_uuid.eq(collection_uuid))
.set((
users_collections::user_uuid.eq(user_uuid),
users_collections::collection_uuid.eq(collection_uuid),
users_collections::read_only.eq(read_only),
users_collections::hide_passwords.eq(hide_passwords),
))
.execute(conn)
.map_res("Error adding user to collection")
}
Err(e) => Err(e.into()),
}.map_res("Error adding user to collection")
} }
postgresql { postgresql {
diesel::insert_into(users_collections::table) diesel::insert_into(users_collections::table)
@ -344,8 +372,11 @@ impl CollectionCipher {
pub fn save(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult { pub fn save(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult {
Self::update_users_revision(&collection_uuid, conn); Self::update_users_revision(&collection_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// Table ciphers_collections does not have ForeignKey Constraints which would cause conflicts.
// This table has no constraints pointing to itself, but only to others.
diesel::replace_into(ciphers_collections::table) diesel::replace_into(ciphers_collections::table)
.values(( .values((
ciphers_collections::cipher_uuid.eq(cipher_uuid), ciphers_collections::cipher_uuid.eq(cipher_uuid),
@ -370,7 +401,7 @@ impl CollectionCipher {
pub fn delete(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult { pub fn delete(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult {
Self::update_users_revision(&collection_uuid, conn); Self::update_users_revision(&collection_uuid, conn);
db_run! { conn: { db_run! { conn: {
diesel::delete( diesel::delete(
ciphers_collections::table ciphers_collections::table

30
src/db/models/folder.rs
Datei anzeigen

@ -74,12 +74,23 @@ impl Folder {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
self.updated_at = Utc::now().naive_utc(); self.updated_at = Utc::now().naive_utc();
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(folders::table) match diesel::replace_into(folders::table)
.values(FolderDb::to_db(self)) .values(FolderDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving folder") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(folders::table)
.filter(folders::uuid.eq(&self.uuid))
.set(FolderDb::to_db(self))
.execute(conn)
.map_res("Error saving folder")
}
Err(e) => Err(e.into()),
}.map_res("Error saving folder")
} }
postgresql { postgresql {
let value = FolderDb::to_db(self); let value = FolderDb::to_db(self);
@ -98,7 +109,7 @@ impl Folder {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
FolderCipher::delete_all_by_folder(&self.uuid, &conn)?; FolderCipher::delete_all_by_folder(&self.uuid, &conn)?;
db_run! { conn: { db_run! { conn: {
diesel::delete(folders::table.filter(folders::uuid.eq(&self.uuid))) diesel::delete(folders::table.filter(folders::uuid.eq(&self.uuid)))
.execute(conn) .execute(conn)
@ -136,8 +147,11 @@ impl Folder {
impl FolderCipher { impl FolderCipher {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// Table folders_ciphers does not have ForeignKey Constraints which would cause conflicts.
// This table has no constraints pointing to itself, but only to others.
diesel::replace_into(folders_ciphers::table) diesel::replace_into(folders_ciphers::table)
.values(FolderCipherDb::to_db(self)) .values(FolderCipherDb::to_db(self))
.execute(conn) .execute(conn)
@ -149,9 +163,9 @@ impl FolderCipher {
.on_conflict((folders_ciphers::cipher_uuid, folders_ciphers::folder_uuid)) .on_conflict((folders_ciphers::cipher_uuid, folders_ciphers::folder_uuid))
.do_nothing() .do_nothing()
.execute(conn) .execute(conn)
.map_res("Error adding cipher to folder") .map_res("Error adding cipher to folder")
} }
} }
} }
pub fn delete(self, conn: &DbConn) -> EmptyResult { pub fn delete(self, conn: &DbConn) -> EmptyResult {

17
src/db/models/org_policy.rs
Datei anzeigen

@ -56,12 +56,23 @@ impl OrgPolicy {
/// Database methods /// Database methods
impl OrgPolicy { impl OrgPolicy {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(org_policies::table) match diesel::replace_into(org_policies::table)
.values(OrgPolicyDb::to_db(self)) .values(OrgPolicyDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving org_policy") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(org_policies::table)
.filter(org_policies::uuid.eq(&self.uuid))
.set(OrgPolicyDb::to_db(self))
.execute(conn)
.map_res("Error saving org_policy")
}
Err(e) => Err(e.into()),
}.map_res("Error saving org_policy")
} }
postgresql { postgresql {
let value = OrgPolicyDb::to_db(self); let value = OrgPolicyDb::to_db(self);

41
src/db/models/organization.rs
Datei anzeigen

@ -204,12 +204,24 @@ impl Organization {
User::update_uuid_revision(&user_org.user_uuid, conn); User::update_uuid_revision(&user_org.user_uuid, conn);
}); });
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(organizations::table) match diesel::replace_into(organizations::table)
.values(OrganizationDb::to_db(self)) .values(OrganizationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving organization") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(organizations::table)
.filter(organizations::uuid.eq(&self.uuid))
.set(OrganizationDb::to_db(self))
.execute(conn)
.map_res("Error saving organization")
}
Err(e) => Err(e.into()),
}.map_res("Error saving organization")
} }
postgresql { postgresql {
let value = OrganizationDb::to_db(self); let value = OrganizationDb::to_db(self);
@ -219,7 +231,7 @@ impl Organization {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving organization") .map_res("Error saving organization")
} }
} }
} }
@ -259,7 +271,7 @@ impl Organization {
impl UserOrganization { impl UserOrganization {
pub fn to_json(&self, conn: &DbConn) -> Value { pub fn to_json(&self, conn: &DbConn) -> Value {
let org = Organization::find_by_uuid(&self.org_uuid, conn).unwrap(); let org = Organization::find_by_uuid(&self.org_uuid, conn).unwrap();
json!({ json!({
"Id": self.org_uuid, "Id": self.org_uuid,
"Name": org.name, "Name": org.name,
@ -343,12 +355,23 @@ impl UserOrganization {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users_organizations::table) match diesel::replace_into(users_organizations::table)
.values(UserOrganizationDb::to_db(self)) .values(UserOrganizationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error adding user to organization") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users_organizations::table)
.filter(users_organizations::uuid.eq(&self.uuid))
.set(UserOrganizationDb::to_db(self))
.execute(conn)
.map_res("Error adding user to organization")
}
Err(e) => Err(e.into()),
}.map_res("Error adding user to organization")
} }
postgresql { postgresql {
let value = UserOrganizationDb::to_db(self); let value = UserOrganizationDb::to_db(self);
@ -358,7 +381,7 @@ impl UserOrganization {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error adding user to organization") .map_res("Error adding user to organization")
} }
} }
} }

19
src/db/models/two_factor.rs
Datei anzeigen

@ -71,12 +71,23 @@ impl TwoFactor {
/// Database methods /// Database methods
impl TwoFactor { impl TwoFactor {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(twofactor::table) match diesel::replace_into(twofactor::table)
.values(TwoFactorDb::to_db(self)) .values(TwoFactorDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving twofactor") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(twofactor::table)
.filter(twofactor::uuid.eq(&self.uuid))
.set(TwoFactorDb::to_db(self))
.execute(conn)
.map_res("Error saving twofactor")
}
Err(e) => Err(e.into()),
}.map_res("Error saving twofactor")
} }
postgresql { postgresql {
let value = TwoFactorDb::to_db(self); let value = TwoFactorDb::to_db(self);
@ -93,7 +104,7 @@ impl TwoFactor {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving twofactor") .map_res("Error saving twofactor")
} }
} }
} }

23
src/db/models/user.rs
Datei anzeigen

@ -175,10 +175,21 @@ impl User {
db_run! {conn: db_run! {conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users::table) // Insert or update match diesel::replace_into(users::table)
.values(&UserDb::to_db(self)) .values(UserDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving user") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users::table)
.filter(users::uuid.eq(&self.uuid))
.set(UserDb::to_db(self))
.execute(conn)
.map_res("Error saving user")
}
Err(e) => Err(e.into()),
}.map_res("Error saving user")
} }
postgresql { postgresql {
let value = UserDb::to_db(self); let value = UserDb::to_db(self);
@ -290,10 +301,12 @@ impl Invitation {
db_run! {conn: db_run! {conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here
// Table invitations does not have any ForeignKey Constraints.
diesel::replace_into(invitations::table) diesel::replace_into(invitations::table)
.values(InvitationDb::to_db(self)) .values(InvitationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving invitation") .map_res("Error saving invitation")
} }
postgresql { postgresql {
diesel::insert_into(invitations::table) diesel::insert_into(invitations::table)
@ -301,7 +314,7 @@ impl Invitation {
.on_conflict(invitations::email) .on_conflict(invitations::email)
.do_nothing() .do_nothing()
.execute(conn) .execute(conn)
.map_res("Error saving invitation") .map_res("Error saving invitation")
} }
} }
} }