github.com/yasker/longhorn-engine@v0.0.0-20160621014712-6ed6cfca0729/replica/backup_test.go (about)

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