github.com/rancher/longhorn-engine@v0.6.2/replica/backup_test.go (about)

     1  package replica
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"path"
     7  
     8  	"github.com/longhorn/longhorn-engine/util"
     9  	. "gopkg.in/check.v1"
    10  )
    11  
    12  const (
    13  	mb = 1 << 20
    14  )
    15  
    16  func (s *TestSuite) TestBackup(c *C) {
    17  	dir, err := ioutil.TempDir("", "replica")
    18  	c.Assert(err, IsNil)
    19  	defer os.RemoveAll(dir)
    20  
    21  	err = os.Chdir(dir)
    22  	c.Assert(err, IsNil)
    23  
    24  	r, err := New(10*mb, bs, dir, nil)
    25  	c.Assert(err, IsNil)
    26  	defer r.Close()
    27  
    28  	buf := make([]byte, 2*mb)
    29  	fill(buf, 1)
    30  	_, err = r.WriteAt(buf, mb)
    31  	c.Assert(err, IsNil)
    32  
    33  	rb := NewBackup(nil)
    34  	volume := "test"
    35  
    36  	snap := "000"
    37  	createdTime := util.Now()
    38  	err = r.Snapshot(snap, true, createdTime, nil)
    39  	c.Assert(err, IsNil)
    40  
    41  	err = rb.OpenSnapshot(snap, volume)
    42  	c.Assert(err, IsNil)
    43  
    44  	mappings, err := rb.CompareSnapshot(snap, "", volume)
    45  	c.Assert(err, IsNil)
    46  	c.Assert(len(mappings.Mappings), Equals, 2)
    47  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
    48  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(0))
    49  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
    50  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(2*mb))
    51  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
    52  }
    53  
    54  func (s *TestSuite) TestBackupWithBackups(c *C) {
    55  	s.testBackupWithBackups(c, nil)
    56  }
    57  
    58  func (s *TestSuite) TestBackupWithBackupsAndBacking(c *C) {
    59  	dir, err := ioutil.TempDir("", "replica")
    60  	c.Assert(err, IsNil)
    61  	defer os.RemoveAll(dir)
    62  
    63  	f, err := os.Create(path.Join(dir, "backing"))
    64  	c.Assert(err, IsNil)
    65  	defer f.Close()
    66  
    67  	buf := make([]byte, 10*mb)
    68  	fill(buf, 9)
    69  
    70  	_, err = f.Write(buf)
    71  	c.Assert(err, IsNil)
    72  
    73  	backing := &BackingFile{
    74  		Name: "backing",
    75  		Disk: f,
    76  	}
    77  
    78  	s.testBackupWithBackups(c, backing)
    79  }
    80  
    81  func (s *TestSuite) testBackupWithBackups(c *C, backingFile *BackingFile) {
    82  	dir, err := ioutil.TempDir("", "replica")
    83  	c.Assert(err, IsNil)
    84  	defer os.RemoveAll(dir)
    85  
    86  	err = os.Chdir(dir)
    87  	c.Assert(err, IsNil)
    88  	volume := "test"
    89  
    90  	r, err := New(10*mb, bs, dir, backingFile)
    91  	c.Assert(err, IsNil)
    92  	defer r.Close()
    93  
    94  	// Write layout as follows
    95  	//               0 1 2 3 4 5 6 7 8 9 mb
    96  	// chain[0] head 4 4 4 4 4 4 4 4 4 4
    97  	// chain[1] 003          3 3     3 3
    98  	// chain[2] 002  2 2     2 2
    99  	// chain[3] 001    1 1
   100  	// chain[4] back 9 9 9 9 9 9 9 9 9 9
   101  	buf := make([]byte, 2*mb)
   102  	fill(buf, 1)
   103  	_, err = r.WriteAt(buf, mb)
   104  	c.Assert(err, IsNil)
   105  
   106  	snap1 := "001"
   107  	createdTime1 := util.Now()
   108  	err = r.Snapshot(snap1, true, createdTime1, nil)
   109  
   110  	snap2 := "002"
   111  	c.Assert(err, IsNil)
   112  	fill(buf, 2)
   113  	_, err = r.WriteAt(buf, 0)
   114  	c.Assert(err, IsNil)
   115  	_, err = r.WriteAt(buf, 4*mb)
   116  	c.Assert(err, IsNil)
   117  	createdTime2 := util.Now()
   118  	err = r.Snapshot(snap2, true, createdTime2, nil)
   119  	c.Assert(err, IsNil)
   120  
   121  	snap3 := "003"
   122  	fill(buf, 3)
   123  	_, err = r.WriteAt(buf, 4*mb)
   124  	c.Assert(err, IsNil)
   125  	_, err = r.WriteAt(buf, 8*mb)
   126  	c.Assert(err, IsNil)
   127  	createdTime3 := util.Now()
   128  	err = r.Snapshot(snap3, true, createdTime3, nil)
   129  
   130  	c.Assert(err, IsNil)
   131  	buf = make([]byte, 10*mb)
   132  	fill(buf, 4)
   133  	_, err = r.WriteAt(buf, 0)
   134  	c.Assert(err, IsNil)
   135  
   136  	rb := NewBackup(backingFile)
   137  
   138  	// Test 003 -> ""
   139  	c.Assert(err, IsNil)
   140  	err = rb.OpenSnapshot(snap3, volume)
   141  	c.Assert(err, IsNil)
   142  
   143  	// Test read 003
   144  	expected := make([]byte, 10*mb)
   145  	readBuf := make([]byte, 10*mb)
   146  	fill(expected[:2*mb], 2)
   147  	fill(expected[2*mb:3*mb], 1)
   148  	fill(expected[4*mb:6*mb], 3)
   149  	fill(expected[8*mb:10*mb], 3)
   150  	if backingFile != nil {
   151  		fill(expected[3*mb:4*mb], 9)
   152  		fill(expected[6*mb:8*mb], 9)
   153  	}
   154  	err = rb.ReadSnapshot(snap3, volume, 0, readBuf)
   155  	c.Assert(err, IsNil)
   156  	md5Equals(c, readBuf, expected)
   157  
   158  	mappings, err := rb.CompareSnapshot(snap3, "", volume)
   159  	c.Assert(err, IsNil)
   160  	c.Assert(len(mappings.Mappings), Equals, 4)
   161  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
   162  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(0))
   163  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
   164  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(2*mb))
   165  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
   166  	c.Assert(mappings.Mappings[2].Offset, Equals, int64(4*mb))
   167  	c.Assert(mappings.Mappings[2].Size, Equals, int64(2*mb))
   168  	c.Assert(mappings.Mappings[3].Offset, Equals, int64(8*mb))
   169  	c.Assert(mappings.Mappings[3].Size, Equals, int64(2*mb))
   170  
   171  	err = rb.CloseSnapshot(snap3, volume)
   172  	c.Assert(err, IsNil)
   173  
   174  	// Test 003 -> 002
   175  	err = rb.OpenSnapshot(snap3, volume)
   176  	mappings, err = rb.CompareSnapshot(snap3, snap2, volume)
   177  	c.Assert(err, IsNil)
   178  	c.Assert(len(mappings.Mappings), Equals, 2)
   179  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
   180  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(4*mb))
   181  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
   182  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(8*mb))
   183  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
   184  	err = rb.CloseSnapshot(snap3, volume)
   185  
   186  	// Test 002 -> 001
   187  	err = rb.OpenSnapshot(snap2, volume)
   188  	c.Assert(err, IsNil)
   189  
   190  	// Test read 002
   191  	expected = make([]byte, 10*mb)
   192  	readBuf = make([]byte, 10*mb)
   193  	fill(expected[:2*mb], 2)
   194  	fill(expected[2*mb:3*mb], 1)
   195  	fill(expected[4*mb:6*mb], 2)
   196  	if backingFile != nil {
   197  		fill(expected[3*mb:4*mb], 9)
   198  		fill(expected[6*mb:10*mb], 9)
   199  	}
   200  	err = rb.ReadSnapshot(snap2, volume, 0, readBuf)
   201  	c.Assert(err, IsNil)
   202  	md5Equals(c, readBuf, expected)
   203  
   204  	mappings, err = rb.CompareSnapshot(snap2, snap1, volume)
   205  	c.Assert(err, IsNil)
   206  	c.Assert(len(mappings.Mappings), Equals, 2)
   207  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
   208  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(0*mb))
   209  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
   210  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(4*mb))
   211  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
   212  	err = rb.CloseSnapshot(snap2, volume)
   213  	c.Assert(err, IsNil)
   214  
   215  	// Test 002 -> ""
   216  	err = rb.OpenSnapshot(snap2, volume)
   217  	c.Assert(err, IsNil)
   218  	mappings, err = rb.CompareSnapshot(snap2, "", volume)
   219  	c.Assert(err, IsNil)
   220  	c.Assert(len(mappings.Mappings), Equals, 3)
   221  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
   222  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(0*mb))
   223  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
   224  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(2*mb))
   225  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
   226  	c.Assert(mappings.Mappings[2].Offset, Equals, int64(4*mb))
   227  	c.Assert(mappings.Mappings[2].Size, Equals, int64(2*mb))
   228  	err = rb.CloseSnapshot(snap2, volume)
   229  	c.Assert(err, IsNil)
   230  
   231  	// Test 001 -> ""
   232  	err = rb.OpenSnapshot(snap1, volume)
   233  	c.Assert(err, IsNil)
   234  
   235  	// Test read 001
   236  	expected = make([]byte, 10*mb)
   237  	readBuf = make([]byte, 10*mb)
   238  	fill(expected[mb:3*mb], 1)
   239  	if backingFile != nil {
   240  		fill(expected[:mb], 9)
   241  		fill(expected[3*mb:10*mb], 9)
   242  	}
   243  	err = rb.ReadSnapshot(snap1, volume, 0, readBuf)
   244  	c.Assert(err, IsNil)
   245  	md5Equals(c, readBuf, expected)
   246  
   247  	mappings, err = rb.CompareSnapshot(snap1, "", volume)
   248  	c.Assert(err, IsNil)
   249  	c.Assert(len(mappings.Mappings), Equals, 2)
   250  	c.Assert(mappings.BlockSize, Equals, int64(2*mb))
   251  	c.Assert(mappings.Mappings[0].Offset, Equals, int64(0*mb))
   252  	c.Assert(mappings.Mappings[0].Size, Equals, int64(2*mb))
   253  	c.Assert(mappings.Mappings[1].Offset, Equals, int64(2*mb))
   254  	c.Assert(mappings.Mappings[1].Size, Equals, int64(2*mb))
   255  	err = rb.CloseSnapshot(snap1, volume)
   256  	c.Assert(err, IsNil)
   257  }