Remove migration paths from 0.1 branch

src/garage/Cargo.toml

@@ -29,7 +29,6 @@ log = "0.4"
 pretty_env_logger = "0.4"
 
 sled = "0.34"
-old_sled = { package = "sled", version = "0.31" }
 
 structopt = { version = "0.3", default-features = false }
 toml = "0.5"

src/garage/server.rs

@@ -40,28 +40,7 @@ pub async fn run_server(config_file: PathBuf) -> Result<(), Error> {
 	info!("Opening database...");
 	let mut db_path = config.metadata_dir.clone();
 	db_path.push("db");
-	let db = match sled::open(&db_path) {
-		Ok(db) => db,
-		Err(e) => {
-			warn!("Old DB could not be openned ({}), attempting migration.", e);
-			let old = old_sled::open(&db_path).expect("Unable to open old DB for migration");
-			let mut new_path = config.metadata_dir.clone();
-			new_path.push("db2");
-			let new = sled::open(&new_path).expect("Unable to open new DB for migration");
-			new.import(old.export());
-			if old.checksum().expect("unable to compute old db checksum")
-				!= new.checksum().expect("unable to compute new db checksum")
-			{
-				panic!("db checksums don't match after migration");
-			}
-			drop(new);
-			drop(old);
-			std::fs::remove_dir_all(&db_path).expect("Cannot remove old DB folder");
-			std::fs::rename(new_path, &db_path)
-				.expect("Cannot move new DB folder to correct place");
-			sled::open(db_path).expect("Unable to open new DB after migration")
-		}
-	};
+	let db = sled::open(&db_path).expect("Unable to open sled DB");
 
 	info!("Initialize RPC server...");
 	let mut rpc_server = RpcServer::new(config.rpc_bind_addr.clone(), config.rpc_tls.clone());

src/model/Cargo.toml

@@ -16,7 +16,6 @@ path = "lib.rs"
 garage_util = { version = "0.1.1", path = "../util" }
 garage_rpc = { version = "0.1.1", path = "../rpc" }
 garage_table = { version = "0.1.1", path = "../table" }
-model010 = { package = "garage_model_010b", version = "0.0.1" }
 
 bytes = "0.4"
 rand = "0.7"

src/model/bucket_table.rs

@@ -5,11 +5,6 @@ use garage_table::*;
 
 use crate::key_table::PermissionSet;
 
-// We import the same file but in its version 0.1.0.
-// We can then access v0.1.0 data structures.
-// We use them to perform migrations.
-use model010::bucket_table as prev;
-
 /// A bucket is a collection of objects
 ///
 /// Its parameters are not directly accessible as:
@@ -108,39 +103,4 @@ impl TableSchema for BucketTable {
 	fn matches_filter(entry: &Self::E, filter: &Self::Filter) -> bool {
 		filter.apply(entry.is_deleted())
 	}
-
-	fn try_migrate(bytes: &[u8]) -> Option<Self::E> {
-		let old = match rmp_serde::decode::from_read_ref::<_, prev::Bucket>(bytes) {
-			Ok(x) => x,
-			Err(_) => return None,
-		};
-		if old.deleted {
-			Some(Bucket {
-				name: old.name,
-				state: crdt::LWW::migrate_from_raw(old.timestamp, BucketState::Deleted),
-			})
-		} else {
-			let mut keys = crdt::LWWMap::new();
-			for ak in old.authorized_keys() {
-				keys.merge(&crdt::LWWMap::migrate_from_raw_item(
-					ak.key_id.clone(),
-					ak.timestamp,
-					PermissionSet {
-						allow_read: ak.allow_read,
-						allow_write: ak.allow_write,
-					},
-				));
-			}
-
-			let params = BucketParams {
-				authorized_keys: keys,
-				website: crdt::LWW::new(false),
-			};
-
-			Some(Bucket {
-				name: old.name,
-				state: crdt::LWW::migrate_from_raw(old.timestamp, BucketState::Present(params)),
-			})
-		}
-	}
 }

src/model/key_table.rs

@@ -3,8 +3,6 @@ use serde::{Deserialize, Serialize};
 use garage_table::crdt::*;
 use garage_table::*;
 
-use model010::key_table as prev;
-
 #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
 pub struct Key {
 	// Primary key
@@ -103,30 +101,4 @@ impl TableSchema for KeyTable {
 	fn matches_filter(entry: &Self::E, filter: &Self::Filter) -> bool {
 		filter.apply(entry.deleted.get())
 	}
-
-	fn try_migrate(bytes: &[u8]) -> Option<Self::E> {
-		let old = match rmp_serde::decode::from_read_ref::<_, prev::Key>(bytes) {
-			Ok(x) => x,
-			Err(_) => return None,
-		};
-		let mut new = Self::E {
-			key_id: old.key_id.clone(),
-			secret_key: old.secret_key.clone(),
-			name: crdt::LWW::migrate_from_raw(old.name_timestamp, old.name.clone()),
-			deleted: crdt::Bool::new(old.deleted),
-			authorized_buckets: crdt::LWWMap::new(),
-		};
-		for ab in old.authorized_buckets() {
-			let it = crdt::LWWMap::migrate_from_raw_item(
-				ab.bucket.clone(),
-				ab.timestamp,
-				PermissionSet {
-					allow_read: ab.allow_read,
-					allow_write: ab.allow_write,
-				},
-			);
-			new.authorized_buckets.merge(&it);
-		}
-		Some(new)
-	}
 }

src/model/object_table.rs

@@ -11,8 +11,6 @@ use garage_table::*;
 
 use crate::version_table::*;
 
-use model010::object_table as prev;
-
 #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
 pub struct Object {
 	// Primary key
@@ -226,55 +224,5 @@ impl TableSchema for ObjectTable {
 		let deleted = !entry.versions.iter().any(|v| v.is_data());
 		filter.apply(deleted)
 	}
-
-	fn try_migrate(bytes: &[u8]) -> Option<Self::E> {
-		let old = match rmp_serde::decode::from_read_ref::<_, prev::Object>(bytes) {
-			Ok(x) => x,
-			Err(_) => return None,
-		};
-		let new_v = old
-			.versions()
-			.iter()
-			.map(migrate_version)
-			.collect::<Vec<_>>();
-		let new = Object::new(old.bucket.clone(), old.key.clone(), new_v);
-		Some(new)
-	}
 }
 
-fn migrate_version(old: &prev::ObjectVersion) -> ObjectVersion {
-	let headers = ObjectVersionHeaders {
-		content_type: old.mime_type.clone(),
-		other: BTreeMap::new(),
-	};
-	let meta = ObjectVersionMeta {
-		headers: headers.clone(),
-		size: old.size,
-		etag: "".to_string(),
-	};
-	let state = match old.state {
-		prev::ObjectVersionState::Uploading => ObjectVersionState::Uploading(headers),
-		prev::ObjectVersionState::Aborted => ObjectVersionState::Aborted,
-		prev::ObjectVersionState::Complete => match &old.data {
-			prev::ObjectVersionData::Uploading => ObjectVersionState::Uploading(headers),
-			prev::ObjectVersionData::DeleteMarker => {
-				ObjectVersionState::Complete(ObjectVersionData::DeleteMarker)
-			}
-			prev::ObjectVersionData::Inline(x) => {
-				ObjectVersionState::Complete(ObjectVersionData::Inline(meta, x.clone()))
-			}
-			prev::ObjectVersionData::FirstBlock(h) => {
-				let mut hash = [0u8; 32];
-				hash.copy_from_slice(h.as_ref());
-				ObjectVersionState::Complete(ObjectVersionData::FirstBlock(meta, Hash::from(hash)))
-			}
-		},
-	};
-	let mut uuid = [0u8; 32];
-	uuid.copy_from_slice(old.uuid.as_ref());
-	ObjectVersion {
-		uuid: UUID::from(uuid),
-		timestamp: old.timestamp,
-		state,
-	}
-}