[ceph.git] / ceph / qa / tasks / mgr / dashboard / test_rbd_mirroring.py

# -*- coding: utf-8 -*-
# pylint: disable=too-many-public-methods

from __future__ import absolute_import

from tasks.mgr.dashboard.helper import DashboardTestCase


class RbdMirroringTest(DashboardTestCase):
    AUTH_ROLES = ['pool-manager', 'block-manager']

    @classmethod
    def create_pool(cls, name, application='rbd'):
        data = {
            'pool': name,
            'pg_num': 2**3,
            'pool_type': 'replicated',
            'application_metadata': [application]
        }
        cls._task_post("/api/pool", data)

    @classmethod
    def get_pool(cls, pool):
        data = cls._get('/api/block/mirroring/pool/{}'.format(pool))
        if isinstance(data, dict):
            return data
        return {}

    @classmethod
    def update_pool(cls, pool, mirror_mode):
        data = {'mirror_mode': mirror_mode}
        return cls._task_put('/api/block/mirroring/pool/{}'.format(pool),
                             data)

    @classmethod
    def list_peers(cls, pool):
        data = cls._get('/api/block/mirroring/pool/{}/peer'.format(pool))
        if isinstance(data, list):
            return data
        return []

    @classmethod
    def get_peer(cls, pool, peer_uuid):
        data = cls._get('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid))
        if isinstance(data, dict):
            return data
        return {}

    @classmethod
    def create_peer(cls, pool, cluster_name, client_id, **kwargs):
        data = {'cluster_name': cluster_name, 'client_id': client_id}
        data.update(kwargs)
        return cls._task_post('/api/block/mirroring/pool/{}/peer'.format(pool),
                              data)

    @classmethod
    def update_peer(cls, pool, peer_uuid, **kwargs):
        return cls._task_put('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid),
                             kwargs)

    @classmethod
    def delete_peer(cls, pool, peer_uuid):
        return cls._task_delete('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid))

    @classmethod
    def setUpClass(cls):
        super(RbdMirroringTest, cls).setUpClass()
        cls.create_pool('rbd')

    @classmethod
    def tearDownClass(cls):
        super(RbdMirroringTest, cls).tearDownClass()
        cls._ceph_cmd(['osd', 'pool', 'delete', 'rbd', 'rbd', '--yes-i-really-really-mean-it'])

    @DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['create', 'update', 'delete']}])
    def test_read_access_permissions(self):
        self.get_pool('rbd')
        self.assertStatus(403)
        self.list_peers('rbd')
        self.assertStatus(403)
        self.get_peer('rbd', '123')
        self.assertStatus(403)

    @DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'update', 'delete']}])
    def test_create_access_permissions(self):
        self.create_peer('rbd', 'remote', 'id')
        self.assertStatus(403)

    @DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'create', 'delete']}])
    def test_update_access_permissions(self):
        self.update_peer('rbd', '123')
        self.assertStatus(403)

    @DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'create', 'update']}])
    def test_delete_access_permissions(self):
        self.delete_peer('rbd', '123')
        self.assertStatus(403)

    def test_mirror_mode(self):
        self.update_pool('rbd', 'disabled')
        mode = self.get_pool('rbd').get('mirror_mode')
        self.assertEqual(mode, 'disabled')

        self.update_pool('rbd', 'image')
        mode = self.get_pool('rbd').get('mirror_mode')
        self.assertEqual(mode, 'image')

        self.update_pool('rbd', 'pool')
        mode = self.get_pool('rbd').get('mirror_mode')
        self.assertEqual(mode, 'pool')

        self.update_pool('rbd', 'disabled')
        mode = self.get_pool('rbd').get('mirror_mode')
        self.assertEqual(mode, 'disabled')

    def test_set_invalid_mirror_mode(self):
        self.update_pool('rbd', 'invalid')
        self.assertStatus(400)

    def test_set_same_mirror_mode(self):
        self.update_pool('rbd', 'disabled')
        self.update_pool('rbd', 'disabled')
        self.assertStatus(200)

    def test_peer(self):
        self.update_pool('rbd', 'image')
        self.assertStatus(200)

        peers = self.list_peers('rbd')
        self.assertStatus(200)
        self.assertEqual([], peers)

        uuid = self.create_peer('rbd', 'remote', 'admin')['uuid']
        self.assertStatus(201)

        peers = self.list_peers('rbd')
        self.assertStatus(200)
        self.assertEqual([uuid], peers)

        expected_peer = {
            'uuid': uuid,
            'cluster_name': 'remote',
            'site_name': 'remote',
            'client_id': 'admin',
            'mon_host': '',
            'key': '',
            'direction': 'rx-tx',
            'mirror_uuid': ''
        }
        peer = self.get_peer('rbd', uuid)
        self.assertEqual(expected_peer, peer)

        self.update_peer('rbd', uuid, mon_host='1.2.3.4')
        self.assertStatus(200)

        expected_peer['mon_host'] = '1.2.3.4'
        peer = self.get_peer('rbd', uuid)
        self.assertEqual(expected_peer, peer)

        self.delete_peer('rbd', uuid)
        self.assertStatus(204)

        self.update_pool('rbd', 'disabled')
        self.assertStatus(200)

    def test_disable_mirror_with_peers(self):
        self.update_pool('rbd', 'image')
        self.assertStatus(200)

        uuid = self.create_peer('rbd', 'remote', 'admin')['uuid']
        self.assertStatus(201)

        self.update_pool('rbd', 'disabled')
        self.assertStatus(400)

        self.delete_peer('rbd', uuid)
        self.assertStatus(204)

        self.update_pool('rbd', 'disabled')
        self.assertStatus(200)

    def test_site_name(self):
        expected_site_name = {'site_name': 'site-a'}
        self._task_put('/api/block/mirroring/site_name', expected_site_name)
        self.assertStatus(200)

        site_name = self._get('/api/block/mirroring/site_name')
        self.assertStatus(200)
        self.assertEqual(expected_site_name, site_name)

    def test_bootstrap(self):
        self.update_pool('rbd', 'image')
        token_data = self._task_post('/api/block/mirroring/pool/rbd/bootstrap/token', {})
        self.assertStatus(200)

        import_data = {
            'token': token_data['token'],
            'direction': 'invalid'}
        self._task_post('/api/block/mirroring/pool/rbd/bootstrap/peer', import_data)
        self.assertStatus(400)

        # cannot import "youself" as peer
        import_data['direction'] = 'rx'
        self._task_post('/api/block/mirroring/pool/rbd/bootstrap/peer', import_data)
        self.assertStatus(400)
Commit	Line	Data
11fdf7f2 TL	1	# -- coding: utf-8 --
	2	# pylint: disable=too-many-public-methods
	3
	4	from __future__ import absolute_import
	5
e306af50	6	from tasks.mgr.dashboard.helper import DashboardTestCase
11fdf7f2 TL	7
	8
	9	class RbdMirroringTest(DashboardTestCase):
	10	AUTH_ROLES = ['pool-manager', 'block-manager']
	11
	12	@classmethod
	13	def create_pool(cls, name, application='rbd'):
	14	data = {
	15	'pool': name,
9f95a23c	16	'pg_num': 2**3,
11fdf7f2 TL	17	'pool_type': 'replicated',
	18	'application_metadata': [application]
	19	}
	20	cls._task_post("/api/pool", data)
	21
	22	@classmethod
	23	def get_pool(cls, pool):
	24	data = cls._get('/api/block/mirroring/pool/{}'.format(pool))
	25	if isinstance(data, dict):
	26	return data
	27	return {}
	28
	29	@classmethod
	30	def update_pool(cls, pool, mirror_mode):
	31	data = {'mirror_mode': mirror_mode}
	32	return cls._task_put('/api/block/mirroring/pool/{}'.format(pool),
9f95a23c	33	data)
11fdf7f2 TL	34
	35	@classmethod
	36	def list_peers(cls, pool):
	37	data = cls._get('/api/block/mirroring/pool/{}/peer'.format(pool))
	38	if isinstance(data, list):
	39	return data
	40	return []
	41
	42	@classmethod
	43	def get_peer(cls, pool, peer_uuid):
	44	data = cls._get('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid))
	45	if isinstance(data, dict):
	46	return data
	47	return {}
	48
	49	@classmethod
	50	def create_peer(cls, pool, cluster_name, client_id, **kwargs):
	51	data = {'cluster_name': cluster_name, 'client_id': client_id}
	52	data.update(kwargs)
	53	return cls._task_post('/api/block/mirroring/pool/{}/peer'.format(pool),
9f95a23c	54	data)
11fdf7f2 TL	55
	56	@classmethod
	57	def update_peer(cls, pool, peer_uuid, **kwargs):
	58	return cls._task_put('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid),
9f95a23c	59	kwargs)
11fdf7f2 TL	60
	61	@classmethod
	62	def delete_peer(cls, pool, peer_uuid):
	63	return cls._task_delete('/api/block/mirroring/pool/{}/peer/{}'.format(pool, peer_uuid))
	64
	65	@classmethod
	66	def setUpClass(cls):
	67	super(RbdMirroringTest, cls).setUpClass()
	68	cls.create_pool('rbd')
	69
	70	@classmethod
	71	def tearDownClass(cls):
	72	super(RbdMirroringTest, cls).tearDownClass()
	73	cls._ceph_cmd(['osd', 'pool', 'delete', 'rbd', 'rbd', '--yes-i-really-really-mean-it'])
	74
	75	@DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['create', 'update', 'delete']}])
	76	def test_read_access_permissions(self):
	77	self.get_pool('rbd')
	78	self.assertStatus(403)
	79	self.list_peers('rbd')
	80	self.assertStatus(403)
	81	self.get_peer('rbd', '123')
	82	self.assertStatus(403)
	83
	84	@DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'update', 'delete']}])
	85	def test_create_access_permissions(self):
	86	self.create_peer('rbd', 'remote', 'id')
	87	self.assertStatus(403)
	88
	89	@DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'create', 'delete']}])
	90	def test_update_access_permissions(self):
	91	self.update_peer('rbd', '123')
	92	self.assertStatus(403)
	93
	94	@DashboardTestCase.RunAs('test', 'test', [{'rbd-mirroring': ['read', 'create', 'update']}])
	95	def test_delete_access_permissions(self):
	96	self.delete_peer('rbd', '123')
	97	self.assertStatus(403)
	98
	99	def test_mirror_mode(self):
	100	self.update_pool('rbd', 'disabled')
	101	mode = self.get_pool('rbd').get('mirror_mode')
	102	self.assertEqual(mode, 'disabled')
	103
	104	self.update_pool('rbd', 'image')
	105	mode = self.get_pool('rbd').get('mirror_mode')
	106	self.assertEqual(mode, 'image')
	107
	108	self.update_pool('rbd', 'pool')
	109	mode = self.get_pool('rbd').get('mirror_mode')
	110	self.assertEqual(mode, 'pool')
	111
	112	self.update_pool('rbd', 'disabled')
	113	mode = self.get_pool('rbd').get('mirror_mode')
	114	self.assertEqual(mode, 'disabled')
	115
	116	def test_set_invalid_mirror_mode(self):
	117	self.update_pool('rbd', 'invalid')
	118	self.assertStatus(400)
	119
	120	def test_set_same_mirror_mode(self):
	121	self.update_pool('rbd', 'disabled')
	122	self.update_pool('rbd', 'disabled')
	123	self.assertStatus(200)
124
125	def test_peer(self):
126	self.update_pool('rbd', 'image')
127	self.assertStatus(200)
128
129	peers = self.list_peers('rbd')
130	self.assertStatus(200)
131	self.assertEqual([], peers)
132
133	uuid = self.create_peer('rbd', 'remote', 'admin')['uuid']
134	self.assertStatus(201)
135
136	peers = self.list_peers('rbd')
137	self.assertStatus(200)
138	self.assertEqual([uuid], peers)
139
140	expected_peer = {
141	'uuid': uuid,
142	'cluster_name': 'remote',
9f95a23c	143	'site_name': 'remote',
11fdf7f2 TL	144	'client_id': 'admin',
11fdf7f2 TL	145	'mon_host': '',
9f95a23c TL	146	'key': '',
	147	'direction': 'rx-tx',
	148	'mirror_uuid': ''
11fdf7f2 TL	149	}
	150	peer = self.get_peer('rbd', uuid)
	151	self.assertEqual(expected_peer, peer)
	152
	153	self.update_peer('rbd', uuid, mon_host='1.2.3.4')
	154	self.assertStatus(200)
	155
	156	expected_peer['mon_host'] = '1.2.3.4'
	157	peer = self.get_peer('rbd', uuid)
	158	self.assertEqual(expected_peer, peer)
	159
	160	self.delete_peer('rbd', uuid)
	161	self.assertStatus(204)
	162
	163	self.update_pool('rbd', 'disabled')
	164	self.assertStatus(200)
	165
	166	def test_disable_mirror_with_peers(self):
	167	self.update_pool('rbd', 'image')
	168	self.assertStatus(200)
	169
	170	uuid = self.create_peer('rbd', 'remote', 'admin')['uuid']
	171	self.assertStatus(201)
	172
	173	self.update_pool('rbd', 'disabled')
	174	self.assertStatus(400)
	175
	176	self.delete_peer('rbd', uuid)
	177	self.assertStatus(204)
	178
	179	self.update_pool('rbd', 'disabled')
	180	self.assertStatus(200)
9f95a23c TL	181
	182	def test_site_name(self):
	183	expected_site_name = {'site_name': 'site-a'}
	184	self._task_put('/api/block/mirroring/site_name', expected_site_name)
	185	self.assertStatus(200)
	186
	187	site_name = self._get('/api/block/mirroring/site_name')
	188	self.assertStatus(200)
	189	self.assertEqual(expected_site_name, site_name)
	190
	191	def test_bootstrap(self):
	192	self.update_pool('rbd', 'image')
	193	token_data = self._task_post('/api/block/mirroring/pool/rbd/bootstrap/token', {})
	194	self.assertStatus(200)
	195
	196	import_data = {
	197	'token': token_data['token'],
	198	'direction': 'invalid'}
	199	self._task_post('/api/block/mirroring/pool/rbd/bootstrap/peer', import_data)
	200	self.assertStatus(400)
	201
	202	# cannot import "youself" as peer
	203	import_data['direction'] = 'rx'
	204	self._task_post('/api/block/mirroring/pool/rbd/bootstrap/peer', import_data)
	205	self.assertStatus(400)