sqlite err panics

Author: leijurv

backup/backup.go

@@ -151,9 +151,7 @@ func DryBackup(rawPaths []string) {
 
 	// scanning
 	tx, err := db.DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	defer tx.Rollback()
 	statuses := make([]FileStatus, 0)
 	var allPathsToBackup []string

backup/database.go

@@ -83,9 +83,7 @@ func dbKeyImpl(interactive bool) []byte {
 		}
 		_, err = db.DB.Exec("INSERT INTO db_key (key, id) VALUES (?, 0)", key)
 	}
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	if len(key) != 16 {
 		panic("bad key")
 	}

backup/hasher.go

@@ -48,9 +48,7 @@ func (s *BackupSession) hashOneFile(plan HashPlan) {
 		log.Println("Updating fs_modifed in db so next time I don't reread this for no reason lol")
 		// this is VERY uncommon, so it is NOT worth maintaining a db WRITE transaction for it sadly
 		_, err := db.DB.Exec("UPDATE files SET fs_modified = ?, permissions = ? WHERE path = ? AND end IS NULL", info.ModTime().Unix(), info.Mode()&os.ModePerm, path)
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 		return
 	}
 
@@ -64,18 +62,14 @@ func (s *BackupSession) hashOneFile(plan HashPlan) {
 		s.hashLateMapLock.Lock() // this lock ensures atomicity between the hashLateMap, and the database (blob_entries and files)
 		defer s.hashLateMapLock.Unlock()
 		tx, err := db.DB.Begin()
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 		defer tx.Rollback() // fileHasKnownData can panic
 		var dbHash []byte
 		err = tx.QueryRow("SELECT hash FROM blob_entries WHERE hash = ?", hash).Scan(&dbHash)
 		if err == nil {
 			// yeah so we already have this hash backed up, so the train stops here. we just need to add this to files table, and we're done!
 			s.fileHasKnownData(tx, path, info, hash)
-			if err := tx.Commit(); err != nil {
-				panic(err)
-			}
+			db.Must(tx.Commit())
 			return nil // done, no need to upload
 		}
 		if err != db.ErrNoRows {

backup/scanner.go

@@ -112,42 +112,27 @@ func (s *BackupSession) pruneDeletedFiles(backupPath string, filesMap map[string
 	// we cannot upgrade the long lived RO transaction to a RW transaction, it would conflict with the intermediary RW transactions, it seems
 	// reusing the tx from scanner results in a sqlite busy panic, very consistently
 	tx, err := db.DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	if !strings.HasSuffix(backupPath, "/") {
 		panic(backupPath) // sanity check, should have already been completed
 	}
 	log.Println("Finally, handling deleted files!")
 	// anything that was in this directory but is no longer can be deleted
 	rows, err := tx.Query("SELECT path FROM files WHERE end IS NULL AND path "+db.StartsWithPattern(1), backupPath)
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	defer rows.Close()
 	for rows.Next() {
 		var databasePath string
-		err := rows.Scan(&databasePath)
-		if err != nil {
-			panic(err)
-		}
+		db.Must(rows.Scan(&databasePath))
 		if _, ok := filesMap[databasePath]; !ok {
 			log.Println(databasePath, "used to exist but does not any longer. Marking as ended.")
 			_, err = tx.Exec("UPDATE files SET end = ? WHERE path = ? AND end IS NULL", s.now, databasePath)
-			if err != nil {
-				panic(err)
-			}
+			db.Must(err)
 		}
 	}
-	err = rows.Err()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(rows.Err())
 	log.Println("Pruner committing")
-	err = tx.Commit()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(tx.Commit())
 	log.Println("Pruner committed")
 }
 
@@ -165,9 +150,7 @@ func (ctx *ScannerTransactionContext) Tx() *sql.Tx {
 	}
 	if ctx.tx == nil {
 		tx, err := db.DB.Begin()
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 		ctx.tx = tx
 		return tx
 	}
@@ -183,10 +166,7 @@ func (ctx *ScannerTransactionContext) Tx() *sql.Tx {
 
 func (ctx *ScannerTransactionContext) Close() {
 	if ctx.tx != nil {
-		err := ctx.tx.Commit()
-		if err != nil {
-			panic(err)
-		}
+		db.Must(ctx.tx.Commit())
 		ctx.tx = nil
 	}
 }

backup/uploader.go

@@ -124,15 +124,11 @@ func (s *BackupSession) executeBlobUploadPlan(plan BlobPlan, serv UploadService)
 	s.hashLateMapLock.Lock() // YES, the database query MUST be within this lock (to make sure that the Commit happens before this defer!)
 	defer s.hashLateMapLock.Unlock()
 	tx, err := db.DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	defer tx.Rollback()
 	// **obviously** all this needs to be in a tx
 	_, err = tx.Exec("INSERT INTO blobs (blob_id, padding_key, size, final_hash) VALUES (?, ?, ?, ?)", blobID, paddingKey, totalSize, hashPostEnc)
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	now := time.Now().Unix()
 	for _, completed := range completeds {
 		if !bytes.Equal(completed.BlobID, blobID) {
@@ -142,16 +138,12 @@ func (s *BackupSession) executeBlobUploadPlan(plan BlobPlan, serv UploadService)
 			panic("sanity check")
 		}
 		_, err = tx.Exec("INSERT INTO blob_storage (blob_id, storage_id, path, checksum, timestamp) VALUES (?, ?, ?, ?, ?)", blobID, completed.StorageID, completed.Path, completed.Checksum, now)
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 	}
 	for _, entry := range entries {
 		// do this first (before fileHasKnownData) because of that pesky foreign key
 		_, err = tx.Exec("INSERT OR IGNORE INTO sizes (hash, size) VALUES (?, ?)", entry.hash, entry.preCompressionSize)
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 		if bytes.Equal(entry.originalPlan.hash, entry.hash) {
 			// fetch ALL the files that hashed to this hash
 			files := s.hashLateMap[utils.SliceToArr(entry.hash)]
@@ -176,34 +168,25 @@ func (s *BackupSession) executeBlobUploadPlan(plan BlobPlan, serv UploadService)
 		}
 		// and either way, make a note of what hash is stored in this blob at this location
 		_, err = tx.Exec("INSERT INTO blob_entries (hash, blob_id, encryption_key, final_size, offset, compression_alg) VALUES (?, ?, ?, ?, ?, ?)", entry.hash, blobID, entry.key, entry.postCompressionSize, entry.offset, entry.compression)
-		if err != nil {
-			panic(err)
-		}
+		db.Must(err)
 	}
 	log.Println("Uploader done with blob", plan)
 	log.Println("Uploader committing to database")
 	txCommitted = true // err on the side of caution - if tx.Commit returns an err, very likely it did not actually commit, but, it's possible! so don't delete the blob if there's ANY chance that the db is expecting this blob to exist.
-	err = tx.Commit()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(tx.Commit())
 	log.Println("Committed uploaded blob")
 }
 
 func (s *BackupSession) fileHasKnownData(tx *sql.Tx, path string, info os.FileInfo, hash []byte) {
 	// important to use the same "now" for both of these queries, so that the file's history is presented without "gaps" (that could be present if we called time.Now() twice in a row)
 	_, err := tx.Exec("UPDATE files SET end = ? WHERE path = ? AND end IS NULL", s.now, path)
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	modTime := info.ModTime().Unix()
 	if modTime < 0 {
 		panic(fmt.Sprintf("Invalid modification time for %s: %d", path, modTime))
 	}
 	_, err = tx.Exec("INSERT INTO files (path, hash, start, fs_modified, permissions) VALUES (?, ?, ?, ?, ?)", path, hash, s.now, modTime, info.Mode()&os.ModePerm)
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 }
 
 // this function should be called if the uploader thread was intended to upload a backup of a certain hash, but failed to do so, for any reason

db/db.go

@@ -19,6 +19,15 @@ var ErrNoRows = sql.ErrNoRows
 
 var DB *sql.DB
 
+// only to be used for sqlite errors
+// sql errors in gb are 1. unrecoverable 2. not expected to ever be user-facing
+// a panic is the right choice
+func Must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
 // see https://sqlite.org/forum/info/eabfcd13dcd71807
 func StartsWithPattern(arg int32) string {
 	return fmt.Sprintf(" BETWEEN (?%d) AND (?%d || x'ff') ", arg, arg)
@@ -47,13 +56,9 @@ func setupDatabase(fullPath string, setupSchema bool) {
 	//log.Println("Opening database file", fullPath)
 	var err error
 	DB, err = sql.Open("sqlite3", fullPath)
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	_, err = DB.Exec("PRAGMA journal_size_limit = 100000000") // 100 megabytes
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	//log.Println("Database connection created")
 	//DB.SetMaxOpenConns(1) // 100x better to block for a few hundred ms than to panic with SQLITE_BUSY!!!!
 	// commenting out until i actually hit a sqlite_busy

db/schema.go

@@ -12,22 +12,13 @@ const (
 func initialSetup() {
 	switch determineDatabaseLayer() {
 	case DATABASE_LAYER_EMPTY:
-		err := schemaVersionOne()
-		if err != nil {
-			panic(err)
-		}
+		Must(schemaVersionOne())
 		fallthrough
 	case DATABASE_LAYER_1:
-		err := schemaVersionTwo()
-		if err != nil {
-			panic(err)
-		}
+		Must(schemaVersionTwo())
 		fallthrough
 	case DATABASE_LAYER_2:
-		err := schemaVersionThree()
-		if err != nil {
-			panic(err)
-		}
+		Must(schemaVersionThree())
 		fallthrough
 	case DATABASE_LAYER_3:
 		// up to date
@@ -54,9 +45,7 @@ To see the final schema that gb actually uses today, refer to schema.sql
 
 func schemaVersionOne() error {
 	tx, err := DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	defer tx.Rollback()
 	_, err = tx.Exec(`
 	CREATE TABLE sizes (
@@ -180,22 +169,15 @@ func schemaVersionOne() error {
 	if err != nil {
 		return err
 	}
-	err = tx.Commit()
-	if err != nil {
-		panic(err)
-	}
+	Must(tx.Commit())
 	return nil
 }
 
 func schemaVersionTwo() error {
 	_, err := DB.Exec("PRAGMA foreign_keys = OFF")
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	tx, err := DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	// defer rollback BUT commit after successful execution
 	defer tx.Rollback() // !!!intended to NOT actually rollback!!!
 	_, err = tx.Exec(`
@@ -248,22 +230,15 @@ func schemaVersionTwo() error {
 	if err != nil {
 		return err
 	}
-	err = tx.Commit()
-	if err != nil {
-		panic(err)
-	}
+	Must(tx.Commit())
 	_, err = DB.Exec("PRAGMA foreign_keys = ON")
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	return nil
 }
 
 func schemaVersionThree() error {
 	tx, err := DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	defer tx.Rollback()
 	_, err = tx.Exec(`
 	DROP INDEX blob_entries_by_blob_id;
@@ -314,32 +289,21 @@ func schemaVersionThree() error {
 	if err != nil {
 		return err
 	}
-	err = tx.Commit()
-	if err != nil {
-		panic(err)
-	}
+	Must(tx.Commit())
 	return nil
 }
 
 func query(query string) string {
 	rows, err := DB.Query(query)
-	if err != nil {
-		panic(err)
-	}
+	Must(err)
 	defer rows.Close()
 	ret := ""
 	for rows.Next() {
 		var tableName string
-		err = rows.Scan(&tableName)
-		if err != nil {
-			panic(err)
-		}
+		Must(rows.Scan(&tableName))
 		ret = ret + tableName + ","
 	}
-	err = rows.Err()
-	if err != nil {
-		panic(err)
-	}
+	Must(rows.Err())
 	return ret
 }
 

download/cat.go

@@ -87,9 +87,7 @@ func LookupBlobEntry(hash []byte, tx *sql.Tx, stor storage_base.Storage) BlobEnt
 			INNER JOIN sizes ON sizes.hash = blob_entries.hash
 		WHERE blob_entries.hash = ? AND blob_storage.storage_id = ?`,
 		hash, stor.GetID()).Scan(&blobID, &offset, &length, &compressionAlg, &key, &path, &expectedSize)
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 
 	return BlobEntryInfo{
 		BlobID:         blobID,
@@ -116,9 +114,7 @@ func Cat(hash []byte, tx *sql.Tx, stor storage_base.Storage) io.Reader {
 
 func CatEz(hash []byte, stor storage_base.Storage) io.Reader {
 	tx, err := db.DB.Begin()
-	if err != nil {
-		panic(err)
-	}
+	db.Must(err)
 	defer tx.Rollback()
 
 	return Cat(hash, tx, stor)