/
polkiloo
/
pg_probackup
GigaCode
beta
ОбзорЦентр заботыВойти

pg_probackup

Форк
0
Ветки: 217Коммиты: 3597Теги: 68
pg_probackup
/tests
/
cfs_restore_test.py 
447 строк · 14.9 Кб
1
"""
2
restore
3
    Syntax:
4


5
    pg_probackup restore -B backupdir --instance instance_name
6
        [-D datadir]
7
        [ -i backup_id | [{--time=time | --xid=xid | --lsn=lsn } [--inclusive=boolean]]][--timeline=timeline] [-T OLDDIR=NEWDIR]
8
        [-j num_threads] [--progress] [-q] [-v]
9


10
"""
11
import os
12
import unittest
13
import shutil
14


15
from .helpers.cfs_helpers import find_by_name
16
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
17


18
tblspace_name = 'cfs_tblspace'
19
tblspace_name_new = 'cfs_tblspace_new'
20


21


22
class CfsRestoreBase(ProbackupTest, unittest.TestCase):
23
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
24
    def setUp(self):
25
        self.backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
26


27
        self.node = self.make_simple_node(
28
            base_dir="{0}/{1}/node".format(self.module_name, self.fname),
29
            set_replication=True,
30
            initdb_params=['--data-checksums'],
31
            pg_options={
32
#                'ptrack_enable': 'on',
33
                'cfs_encryption': 'off',
34
            }
35
        )
36


37
        self.init_pb(self.backup_dir)
38
        self.add_instance(self.backup_dir, 'node', self.node)
39
        self.set_archiving(self.backup_dir, 'node', self.node)
40


41
        self.node.slow_start()
42
        self.create_tblspace_in_node(self.node, tblspace_name, cfs=True)
43


44
        self.add_data_in_cluster()
45


46
        self.backup_id = None
47
        try:
48
            self.backup_id = self.backup_node(self.backup_dir, 'node', self.node, backup_type='full')
49
        except ProbackupException as e:
50
            self.fail(
51
                "ERROR: Full backup failed \n {0} \n {1}".format(
52
                    repr(self.cmd),
53
                    repr(e.message)
54
                )
55
            )
56


57
    def add_data_in_cluster(self):
58
        pass
59


60


61
class CfsRestoreNoencEmptyTablespaceTest(CfsRestoreBase):
62
    # @unittest.expectedFailure
63
    # @unittest.skip("skip")
64
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
65
    def test_restore_empty_tablespace_from_fullbackup(self):
66
        """
67
        Case: Restore empty tablespace from valid full backup.
68
        """
69
        self.node.stop(["-m", "immediate"])
70
        self.node.cleanup()
71
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
72


73
        try:
74
            self.restore_node(self.backup_dir, 'node', self.node, backup_id=self.backup_id)
75
        except ProbackupException as e:
76
            self.fail(
77
                "ERROR: Restore failed. \n {0} \n {1}".format(
78
                    repr(self.cmd),
79
                    repr(e.message)
80
                )
81
            )
82
        self.assertTrue(
83
            find_by_name([self.get_tblspace_path(self.node, tblspace_name)], ["pg_compression"]),
84
            "ERROR: Restored data is not valid. pg_compression not found in tablespace dir."
85
        )
86


87
        try:
88
            self.node.slow_start()
89
        except ProbackupException as e:
90
            self.fail(
91
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
92
                    repr(self.cmd),
93
                    repr(e.message)
94
                )
95
            )
96
        tblspace = self.node.safe_psql(
97
            "postgres",
98
            "SELECT * FROM pg_tablespace WHERE spcname='{0}'".format(tblspace_name)
99
        ).decode("UTF-8")
100
        self.assertTrue(
101
            tblspace_name in tblspace and "compression=true" in tblspace,
102
            "ERROR: The tablespace not restored or it restored without compressions"
103
        )
104


105


106
class CfsRestoreNoencTest(CfsRestoreBase):
107
    def add_data_in_cluster(self):
108
        self.node.safe_psql(
109
            "postgres",
110
            'CREATE TABLE {0} TABLESPACE {1} \
111
                AS SELECT i AS id, MD5(i::text) AS text, \
112
                MD5(repeat(i::text,10))::tsvector AS tsvector \
113
                FROM generate_series(0,1e5) i'.format('t1', tblspace_name)
114
        )
115
        self.table_t1 = self.node.table_checksum("t1")
116


117
    # --- Restore from full backup ---#
118
    # @unittest.expectedFailure
119
    # @unittest.skip("skip")
120
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
121
    def test_restore_from_fullbackup_to_old_location(self):
122
        """
123
        Case: Restore instance from valid full backup to old location.
124
        """
125
        self.node.stop()
126
        self.node.cleanup()
127
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
128


129
        try:
130
            self.restore_node(self.backup_dir, 'node', self.node, backup_id=self.backup_id)
131
        except ProbackupException as e:
132
            self.fail(
133
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
134
                    repr(self.cmd),
135
                    repr(e.message)
136
                )
137
            )
138


139
        self.assertTrue(
140
            find_by_name([self.get_tblspace_path(self.node, tblspace_name)], ['pg_compression']),
141
            "ERROR: File pg_compression not found in tablespace dir"
142
        )
143
        try:
144
            self.node.slow_start()
145
        except ProbackupException as e:
146
            self.fail(
147
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
148
                    repr(self.cmd),
149
                    repr(e.message)
150
                )
151
            )
152


153
        self.assertEqual(
154
            self.node.table_checksum("t1"),
155
            self.table_t1
156
        )
157


158
    # @unittest.expectedFailure
159
    # @unittest.skip("skip")
160
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
161
    def test_restore_from_fullbackup_to_old_location_3_jobs(self):
162
        """
163
        Case: Restore instance from valid full backup to old location.
164
        """
165
        self.node.stop()
166
        self.node.cleanup()
167
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
168


169
        try:
170
            self.restore_node(self.backup_dir, 'node', self.node, backup_id=self.backup_id, options=['-j', '3'])
171
        except ProbackupException as e:
172
            self.fail(
173
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
174
                    repr(self.cmd),
175
                    repr(e.message)
176
                )
177
            )
178
        self.assertTrue(
179
            find_by_name([self.get_tblspace_path(self.node, tblspace_name)], ['pg_compression']),
180
            "ERROR: File pg_compression not found in backup dir"
181
        )
182
        try:
183
            self.node.slow_start()
184
        except ProbackupException as e:
185
            self.fail(
186
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
187
                    repr(self.cmd),
188
                    repr(e.message)
189
                )
190
            )
191


192
        self.assertEqual(
193
            self.node.table_checksum("t1"),
194
            self.table_t1
195
        )
196


197
    # @unittest.expectedFailure
198
    # @unittest.skip("skip")
199
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
200
    def test_restore_from_fullbackup_to_new_location(self):
201
        """
202
        Case: Restore instance from valid full backup to new location.
203
        """
204
        self.node.stop()
205
        self.node.cleanup()
206
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
207


208
        node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(self.module_name, self.fname))
209
        node_new.cleanup()
210


211
        try:
212
            self.restore_node(self.backup_dir, 'node', node_new, backup_id=self.backup_id)
213
            self.set_auto_conf(node_new, {'port': node_new.port})
214
        except ProbackupException as e:
215
            self.fail(
216
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
217
                    repr(self.cmd),
218
                    repr(e.message)
219
                )
220
            )
221
        self.assertTrue(
222
            find_by_name([self.get_tblspace_path(self.node, tblspace_name)], ['pg_compression']),
223
            "ERROR: File pg_compression not found in backup dir"
224
        )
225
        try:
226
            node_new.slow_start()
227
        except ProbackupException as e:
228
            self.fail(
229
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
230
                    repr(self.cmd),
231
                    repr(e.message)
232
                )
233
            )
234


235
        self.assertEqual(
236
            node_new.table_checksum("t1"),
237
            self.table_t1
238
        )
239
        node_new.cleanup()
240


241
    # @unittest.expectedFailure
242
    # @unittest.skip("skip")
243
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
244
    def test_restore_from_fullbackup_to_new_location_5_jobs(self):
245
        """
246
        Case: Restore instance from valid full backup to new location.
247
        """
248
        self.node.stop()
249
        self.node.cleanup()
250
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
251


252
        node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(self.module_name, self.fname))
253
        node_new.cleanup()
254


255
        try:
256
            self.restore_node(self.backup_dir, 'node', node_new, backup_id=self.backup_id, options=['-j', '5'])
257
            self.set_auto_conf(node_new, {'port': node_new.port})
258
        except ProbackupException as e:
259
            self.fail(
260
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
261
                    repr(self.cmd),
262
                    repr(e.message)
263
                )
264
            )
265
        self.assertTrue(
266
            find_by_name([self.get_tblspace_path(self.node, tblspace_name)], ['pg_compression']),
267
            "ERROR: File pg_compression not found in backup dir"
268
        )
269
        try:
270
            node_new.slow_start()
271
        except ProbackupException as e:
272
            self.fail(
273
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
274
                    repr(self.cmd),
275
                    repr(e.message)
276
                )
277
            )
278


279
        self.assertEqual(
280
            node_new.table_checksum("t1"),
281
            self.table_t1
282
        )
283
        node_new.cleanup()
284


285
    # @unittest.expectedFailure
286
    # @unittest.skip("skip")
287
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
288
    def test_restore_from_fullbackup_to_old_location_tablespace_new_location(self):
289
        self.node.stop()
290
        self.node.cleanup()
291
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
292


293
        os.mkdir(self.get_tblspace_path(self.node, tblspace_name_new))
294


295
        try:
296
            self.restore_node(
297
                self.backup_dir,
298
                'node', self.node,
299
                backup_id=self.backup_id,
300
                options=["-T", "{0}={1}".format(
301
                        self.get_tblspace_path(self.node, tblspace_name),
302
                        self.get_tblspace_path(self.node, tblspace_name_new)
303
                    )
304
                ]
305
            )
306
        except ProbackupException as e:
307
            self.fail(
308
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
309
                    repr(self.cmd),
310
                    repr(e.message)
311
                )
312
            )
313
        self.assertTrue(
314
            find_by_name([self.get_tblspace_path(self.node, tblspace_name_new)], ['pg_compression']),
315
            "ERROR: File pg_compression not found in new tablespace location"
316
        )
317
        try:
318
            self.node.slow_start()
319
        except ProbackupException as e:
320
            self.fail(
321
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
322
                    repr(self.cmd),
323
                    repr(e.message)
324
                )
325
            )
326


327
        self.assertEqual(
328
            self.node.table_checksum("t1"),
329
            self.table_t1
330
        )
331


332
    # @unittest.expectedFailure
333
    # @unittest.skip("skip")
334
    @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
335
    def test_restore_from_fullbackup_to_old_location_tablespace_new_location_3_jobs(self):
336
        self.node.stop()
337
        self.node.cleanup()
338
        shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
339


340
        os.mkdir(self.get_tblspace_path(self.node, tblspace_name_new))
341


342
        try:
343
            self.restore_node(
344
                self.backup_dir,
345
                'node', self.node,
346
                backup_id=self.backup_id,
347
                options=["-j", "3", "-T", "{0}={1}".format(
348
                        self.get_tblspace_path(self.node, tblspace_name),
349
                        self.get_tblspace_path(self.node, tblspace_name_new)
350
                    )
351
                ]
352
            )
353
        except ProbackupException as e:
354
            self.fail(
355
                "ERROR: Restore from full backup failed. \n {0} \n {1}".format(
356
                    repr(self.cmd),
357
                    repr(e.message)
358
                )
359
            )
360
        self.assertTrue(
361
            find_by_name([self.get_tblspace_path(self.node, tblspace_name_new)], ['pg_compression']),
362
            "ERROR: File pg_compression not found in new tablespace location"
363
        )
364
        try:
365
            self.node.slow_start()
366
        except ProbackupException as e:
367
            self.fail(
368
                "ERROR: Instance not started after restore. \n {0} \n {1}".format(
369
                    repr(self.cmd),
370
                    repr(e.message)
371
                )
372
            )
373


374
        self.assertEqual(
375
            self.node.table_checksum("t1"),
376
            self.table_t1
377
        )
378


379
    # @unittest.expectedFailure
380
    @unittest.skip("skip")
381
    def test_restore_from_fullbackup_to_new_location_tablespace_new_location(self):
382
        pass
383


384
    # @unittest.expectedFailure
385
    @unittest.skip("skip")
386
    def test_restore_from_fullbackup_to_new_location_tablespace_new_location_5_jobs(self):
387
        pass
388


389
    # @unittest.expectedFailure
390
    @unittest.skip("skip")
391
    def test_restore_from_ptrack(self):
392
        """
393
        Case: Restore from backup to old location
394
        """
395
        pass
396


397
    # @unittest.expectedFailure
398
    @unittest.skip("skip")
399
    def test_restore_from_ptrack_jobs(self):
400
        """
401
        Case: Restore from backup to old location, four jobs
402
        """
403
        pass
404


405
    # @unittest.expectedFailure
406
    @unittest.skip("skip")
407
    def test_restore_from_ptrack_new_jobs(self):
408
        pass
409


410
# --------------------------------------------------------- #
411
    # @unittest.expectedFailure
412
    @unittest.skip("skip")
413
    def test_restore_from_page(self):
414
        """
415
        Case: Restore from backup to old location
416
        """
417
        pass
418


419
    # @unittest.expectedFailure
420
    @unittest.skip("skip")
421
    def test_restore_from_page_jobs(self):
422
        """
423
        Case: Restore from backup to old location, four jobs
424
        """
425
        pass
426


427
    # @unittest.expectedFailure
428
    @unittest.skip("skip")
429
    def test_restore_from_page_new_jobs(self):
430
        """
431
        Case: Restore from backup to new location, four jobs
432
        """
433
        pass
434


435


436
#class CfsRestoreEncEmptyTablespaceTest(CfsRestoreNoencEmptyTablespaceTest):
437
#    # --- Begin --- #
438
#    def setUp(self):
439
#        os.environ["PG_CIPHER_KEY"] = "super_secret_cipher_key"
440
#        super(CfsRestoreNoencEmptyTablespaceTest, self).setUp()
441
#
442
#
443
#class CfsRestoreEncTest(CfsRestoreNoencTest):
444
#    # --- Begin --- #
445
#    def setUp(self):
446
#        os.environ["PG_CIPHER_KEY"] = "super_secret_cipher_key"
447
#        super(CfsRestoreNoencTest, self).setUp()
448

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.