1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
"""
Task for running rbd mirroring daemons and configuring mirroring
"""
import logging
from teuthology.orchestra import run
from teuthology import misc
from teuthology.exceptions import ConfigError
from teuthology.task import Task
from tasks.ceph_manager import get_valgrind_args
from tasks.util import get_remote_for_role
log = logging.getLogger(__name__)
class RBDMirror(Task):
"""
Run an rbd-mirror daemon to sync rbd images between clusters.
This requires two clients (one from each cluster) on the same host
to connect with. The pool configuration should be adjusted by later
test scripts to include the remote client and cluster name. This task
just needs to know how to connect to the local cluster.
For example:
roles:
- [primary.mon.a, primary.osd.0, primary.osd.1, primary.osd.2]
- [secondary.mon.a, secondary.osd.0, secondary.osd.1, secondary.osd.2]
- [primary.client.mirror, secondary.client.mirror]
tasks:
- ceph:
cluster: primary
- ceph:
cluster: secondary
- rbd-mirror:
client: primary.client.mirror
To mirror back to the primary cluster as well, add another
rbd_mirror instance:
- rbd-mirror:
client: secondary.client.mirror
Possible options for this task are:
client: role - ceph client to connect as
valgrind: [--tool=<valgrind tool>] - none by default
coverage: bool - whether this run may be collecting coverage data
thrash: bool - whether this run may be thrashed
"""
def __init__(self, ctx, config):
super(RBDMirror, self).__init__(ctx, config)
self.log = log
def setup(self):
super(RBDMirror, self).setup()
try:
self.client = self.config['client']
except KeyError:
raise ConfigError('rbd-mirror requires a client to connect with')
self.cluster_name, type_, self.client_id = misc.split_role(self.client)
if type_ != 'client':
msg = 'client role ({0}) must be a client'.format(self.client)
raise ConfigError(msg)
self.remote = get_remote_for_role(self.ctx, self.client)
def begin(self):
super(RBDMirror, self).begin()
testdir = misc.get_testdir(self.ctx)
daemon_signal = 'kill'
if 'coverage' in self.config or 'valgrind' in self.config or \
self.config.get('thrash', False):
daemon_signal = 'term'
args = [
'adjust-ulimits',
'ceph-coverage',
'{tdir}/archive/coverage'.format(tdir=testdir),
'daemon-helper',
daemon_signal,
]
if 'valgrind' in self.config:
args = get_valgrind_args(
testdir,
'rbd-mirror-{id}'.format(id=self.client),
args,
self.config.get('valgrind')
)
args.extend([
'rbd-mirror', '--foreground',
'--cluster',
self.cluster_name,
'--id',
self.client_id,
])
self.ctx.daemons.add_daemon(
self.remote, 'rbd-mirror', self.client,
cluster=self.cluster_name,
args=args,
logger=self.log.getChild(self.client),
stdin=run.PIPE,
wait=False,
)
def end(self):
mirror_daemon = self.ctx.daemons.get_daemon('rbd-mirror',
self.client,
self.cluster_name)
mirror_daemon.stop()
super(RBDMirror, self).end()
task = RBDMirror
|
