Function TestDB_Concurrent_WriteTo_and_ConsistentRead

db_test.go:709–795

TestDB_Concurrent_WriteTo checks that issuing WriteTo operations concurrently with commits does not produce corrupted db files. It also verifies that all readonly transactions, which are created based on the same data view, should always read the same data.

(t *testing.T)

// readonly transactions, which are created based on the same data view, should
// always read the same data.
func TestDB_Concurrent_WriteTo_and_ConsistentRead(t *testing.T) {
	o := &bolt.Options{
		NoFreelistSync: false,
		PageSize:       4096,
	}
	db := btesting.MustCreateDBWithOption(t, o)

	wtxs, rtxs := 50, 5
	bucketName := []byte("data")

	var dataLock sync.Mutex
	dataCache := make(map[int][]map[string]string)

	var wg sync.WaitGroup
	wg.Add(wtxs * rtxs)
	f := func(round int, tx *bolt.Tx) {
		defer wg.Done()
		time.Sleep(time.Duration(rand.Intn(200)+10) * time.Millisecond)
		f := filepath.Join(t.TempDir(), fmt.Sprintf("%d-bolt-", round))
		err := tx.CopyFile(f, 0600)
		require.NoError(t, err)

		// read all the data
		b := tx.Bucket(bucketName)
		data := make(map[string]string)
		err = b.ForEach(func(k, v []byte) error {
			data[string(k)] = string(v)
			return nil
		})
		require.NoError(t, err)

		// cache the data
		dataLock.Lock()
		dataSlice := dataCache[round]
		dataSlice = append(dataSlice, data)
		dataCache[round] = dataSlice
		dataLock.Unlock()

		err = tx.Rollback()
		require.NoError(t, err)

		copyOpt := *o
		snap := btesting.MustOpenDBWithOption(t, f, &copyOpt)
		defer snap.MustClose()
		snap.MustCheck()
	}

	err := db.Update(func(tx *bolt.Tx) error {
		_, err := tx.CreateBucket(bucketName)
		return err
	})
	require.NoError(t, err)

	for i := 0; i < wtxs; i++ {
		tx, err := db.Begin(true)
		require.NoError(t, err)

		b := tx.Bucket(bucketName)