-
Notifications
You must be signed in to change notification settings - Fork 1
/
filesystem.py
1534 lines (1259 loc) · 55.8 KB
/
filesystem.py
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
import json
import logging
from gevent import Greenlet
import os
import time
import datetime
import re
import errno
import random
from io import BytesIO, StringIO
from errno import EBUSY
from teuthology.exceptions import CommandFailedError
from teuthology import misc
from teuthology.nuke import clear_firewall
from teuthology.parallel import parallel
from teuthology import contextutil
from tasks.ceph_manager import write_conf
from tasks import ceph_manager
log = logging.getLogger(__name__)
DAEMON_WAIT_TIMEOUT = 120
ROOT_INO = 1
class FileLayout(object):
def __init__(self, pool=None, pool_namespace=None, stripe_unit=None, stripe_count=None, object_size=None):
self.pool = pool
self.pool_namespace = pool_namespace
self.stripe_unit = stripe_unit
self.stripe_count = stripe_count
self.object_size = object_size
@classmethod
def load_from_ceph(layout_str):
# TODO
pass
def items(self):
if self.pool is not None:
yield ("pool", self.pool)
if self.pool_namespace:
yield ("pool_namespace", self.pool_namespace)
if self.stripe_unit is not None:
yield ("stripe_unit", self.stripe_unit)
if self.stripe_count is not None:
yield ("stripe_count", self.stripe_count)
if self.object_size is not None:
yield ("object_size", self.stripe_size)
class ObjectNotFound(Exception):
def __init__(self, object_name):
self._object_name = object_name
def __str__(self):
return "Object not found: '{0}'".format(self._object_name)
class FSMissing(Exception):
def __init__(self, ident):
self.ident = ident
def __str__(self):
return f"File system {self.ident} does not exist in the map"
class FSStatus(object):
"""
Operations on a snapshot of the FSMap.
"""
def __init__(self, mon_manager):
self.mon = mon_manager
self.map = json.loads(self.mon.raw_cluster_cmd("fs", "dump", "--format=json"))
def __str__(self):
return json.dumps(self.map, indent = 2, sort_keys = True)
# Expose the fsmap for manual inspection.
def __getitem__(self, key):
"""
Get a field from the fsmap.
"""
return self.map[key]
def get_filesystems(self):
"""
Iterator for all filesystems.
"""
for fs in self.map['filesystems']:
yield fs
def get_all(self):
"""
Iterator for all the mds_info components in the FSMap.
"""
for info in self.map['standbys']:
yield info
for fs in self.map['filesystems']:
for info in fs['mdsmap']['info'].values():
yield info
def get_standbys(self):
"""
Iterator for all standbys.
"""
for info in self.map['standbys']:
yield info
def get_fsmap(self, fscid):
"""
Get the fsmap for the given FSCID.
"""
for fs in self.map['filesystems']:
if fscid is None or fs['id'] == fscid:
return fs
raise FSMissing(fscid)
def get_fsmap_byname(self, name):
"""
Get the fsmap for the given file system name.
"""
for fs in self.map['filesystems']:
if name is None or fs['mdsmap']['fs_name'] == name:
return fs
raise FSMissing(name)
def get_replays(self, fscid):
"""
Get the standby:replay MDS for the given FSCID.
"""
fs = self.get_fsmap(fscid)
for info in fs['mdsmap']['info'].values():
if info['state'] == 'up:standby-replay':
yield info
def get_ranks(self, fscid):
"""
Get the ranks for the given FSCID.
"""
fs = self.get_fsmap(fscid)
for info in fs['mdsmap']['info'].values():
if info['rank'] >= 0 and info['state'] != 'up:standby-replay':
yield info
def get_rank(self, fscid, rank):
"""
Get the rank for the given FSCID.
"""
for info in self.get_ranks(fscid):
if info['rank'] == rank:
return info
raise RuntimeError("FSCID {0} has no rank {1}".format(fscid, rank))
def get_mds(self, name):
"""
Get the info for the given MDS name.
"""
for info in self.get_all():
if info['name'] == name:
return info
return None
def get_mds_addr(self, name):
"""
Return the instance addr as a string, like "10.214.133.138:6807\/10825"
"""
info = self.get_mds(name)
if info:
return info['addr']
else:
log.warning(json.dumps(list(self.get_all()), indent=2)) # dump for debugging
raise RuntimeError("MDS id '{0}' not found in map".format(name))
def get_mds_addrs(self, name):
"""
Return the instance addr as a string, like "[10.214.133.138:6807 10.214.133.138:6808]"
"""
info = self.get_mds(name)
if info:
return [e['addr'] for e in info['addrs']['addrvec']]
else:
log.warn(json.dumps(list(self.get_all()), indent=2)) # dump for debugging
raise RuntimeError("MDS id '{0}' not found in map".format(name))
def get_mds_gid(self, gid):
"""
Get the info for the given MDS gid.
"""
for info in self.get_all():
if info['gid'] == gid:
return info
return None
def hadfailover(self, status):
"""
Compares two statuses for mds failovers.
Returns True if there is a failover.
"""
for fs in status.map['filesystems']:
for info in fs['mdsmap']['info'].values():
oldinfo = self.get_mds_gid(info['gid'])
if oldinfo is None or oldinfo['incarnation'] != info['incarnation']:
return True
#all matching
return False
class CephCluster(object):
@property
def admin_remote(self):
first_mon = misc.get_first_mon(self._ctx, None)
(result,) = self._ctx.cluster.only(first_mon).remotes.keys()
return result
def __init__(self, ctx) -> None:
self._ctx = ctx
self.mon_manager = ceph_manager.CephManager(self.admin_remote, ctx=ctx, logger=log.getChild('ceph_manager'))
def get_config(self, key, service_type=None):
"""
Get config from mon by default, or a specific service if caller asks for it
"""
if service_type is None:
service_type = 'mon'
service_id = sorted(misc.all_roles_of_type(self._ctx.cluster, service_type))[0]
return self.json_asok(['config', 'get', key], service_type, service_id)[key]
def set_ceph_conf(self, subsys, key, value):
if subsys not in self._ctx.ceph['ceph'].conf:
self._ctx.ceph['ceph'].conf[subsys] = {}
self._ctx.ceph['ceph'].conf[subsys][key] = value
write_conf(self._ctx) # XXX because we don't have the ceph task's config object, if they
# used a different config path this won't work.
def clear_ceph_conf(self, subsys, key):
del self._ctx.ceph['ceph'].conf[subsys][key]
write_conf(self._ctx)
def json_asok(self, command, service_type, service_id, timeout=None):
if timeout is None:
timeout = 15*60
command.insert(0, '--format=json')
proc = self.mon_manager.admin_socket(service_type, service_id, command, timeout=timeout)
response_data = proc.stdout.getvalue().strip()
if len(response_data) > 0:
j = json.loads(response_data)
pretty = json.dumps(j, sort_keys=True, indent=2)
log.debug(f"_json_asok output\n{pretty}")
return j
else:
log.debug("_json_asok output empty")
return None
def is_addr_blocklisted(self, addr=None):
if addr is None:
log.warn("Couldn't get the client address, so the blocklisted "
"status undetermined")
return False
blocklist = json.loads(self.mon_manager.run_cluster_cmd(
args=["osd", "blocklist", "ls", "--format=json"],
stdout=StringIO()).stdout.getvalue())
for b in blocklist:
if addr == b["addr"]:
return True
return False
class MDSCluster(CephCluster):
"""
Collective operations on all the MDS daemons in the Ceph cluster. These
daemons may be in use by various Filesystems.
For the benefit of pre-multi-filesystem tests, this class is also
a parent of Filesystem. The correct way to use MDSCluster going forward is
as a separate instance outside of your (multiple) Filesystem instances.
"""
def __init__(self, ctx):
super(MDSCluster, self).__init__(ctx)
@property
def mds_ids(self):
# do this dynamically because the list of ids may change periodically with cephadm
return list(misc.all_roles_of_type(self._ctx.cluster, 'mds'))
@property
def mds_daemons(self):
return dict([(mds_id, self._ctx.daemons.get_daemon('mds', mds_id)) for mds_id in self.mds_ids])
def _one_or_all(self, mds_id, cb, in_parallel=True):
"""
Call a callback for a single named MDS, or for all.
Note that the parallelism here isn't for performance, it's to avoid being overly kind
to the cluster by waiting a graceful ssh-latency of time between doing things, and to
avoid being overly kind by executing them in a particular order. However, some actions
don't cope with being done in parallel, so it's optional (`in_parallel`)
:param mds_id: MDS daemon name, or None
:param cb: Callback taking single argument of MDS daemon name
:param in_parallel: whether to invoke callbacks concurrently (else one after the other)
"""
if mds_id is None:
if in_parallel:
with parallel() as p:
for mds_id in self.mds_ids:
p.spawn(cb, mds_id)
else:
for mds_id in self.mds_ids:
cb(mds_id)
else:
cb(mds_id)
def get_config(self, key, service_type=None):
"""
get_config specialization of service_type="mds"
"""
if service_type != "mds":
return super(MDSCluster, self).get_config(key, service_type)
# Some tests stop MDS daemons, don't send commands to a dead one:
running_daemons = [i for i, mds in self.mds_daemons.items() if mds.running()]
service_id = random.sample(running_daemons, 1)[0]
return self.json_asok(['config', 'get', key], service_type, service_id)[key]
def mds_stop(self, mds_id=None):
"""
Stop the MDS daemon process(se). If it held a rank, that rank
will eventually go laggy.
"""
self._one_or_all(mds_id, lambda id_: self.mds_daemons[id_].stop())
def mds_fail(self, mds_id=None):
"""
Inform MDSMonitor of the death of the daemon process(es). If it held
a rank, that rank will be relinquished.
"""
self._one_or_all(mds_id, lambda id_: self.mon_manager.raw_cluster_cmd("mds", "fail", id_))
def mds_restart(self, mds_id=None):
self._one_or_all(mds_id, lambda id_: self.mds_daemons[id_].restart())
def mds_fail_restart(self, mds_id=None):
"""
Variation on restart that includes marking MDSs as failed, so that doing this
operation followed by waiting for healthy daemon states guarantees that they
have gone down and come up, rather than potentially seeing the healthy states
that existed before the restart.
"""
def _fail_restart(id_):
self.mds_daemons[id_].stop()
self.mon_manager.raw_cluster_cmd("mds", "fail", id_)
self.mds_daemons[id_].restart()
self._one_or_all(mds_id, _fail_restart)
def mds_signal(self, mds_id, sig, silent=False):
"""
signal a MDS daemon
"""
self.mds_daemons[mds_id].signal(sig, silent);
def newfs(self, name='cephfs', create=True):
return Filesystem(self._ctx, name=name, create=create)
def status(self):
return FSStatus(self.mon_manager)
def get_standby_daemons(self):
return set([s['name'] for s in self.status().get_standbys()])
def get_mds_hostnames(self):
result = set()
for mds_id in self.mds_ids:
mds_remote = self.mon_manager.find_remote('mds', mds_id)
result.add(mds_remote.hostname)
return list(result)
def set_clients_block(self, blocked, mds_id=None):
"""
Block (using iptables) client communications to this MDS. Be careful: if
other services are running on this MDS, or other MDSs try to talk to this
MDS, their communications may also be blocked as collatoral damage.
:param mds_id: Optional ID of MDS to block, default to all
:return:
"""
da_flag = "-A" if blocked else "-D"
def set_block(_mds_id):
remote = self.mon_manager.find_remote('mds', _mds_id)
status = self.status()
addr = status.get_mds_addr(_mds_id)
ip_str, port_str, inst_str = re.match("(.+):(.+)/(.+)", addr).groups()
remote.run(
args=["sudo", "iptables", da_flag, "OUTPUT", "-p", "tcp", "--sport", port_str, "-j", "REJECT", "-m",
"comment", "--comment", "teuthology"])
remote.run(
args=["sudo", "iptables", da_flag, "INPUT", "-p", "tcp", "--dport", port_str, "-j", "REJECT", "-m",
"comment", "--comment", "teuthology"])
self._one_or_all(mds_id, set_block, in_parallel=False)
def set_inter_mds_block(self, blocked, mds_rank_1, mds_rank_2):
"""
Block (using iptables) communications from a provided MDS to other MDSs.
Block all ports that an MDS uses for communication.
:param blocked: True to block the MDS, False otherwise
:param mds_rank_1: MDS rank
:param mds_rank_2: MDS rank
:return:
"""
da_flag = "-A" if blocked else "-D"
def set_block(mds_ids):
status = self.status()
mds = mds_ids[0]
remote = self.mon_manager.find_remote('mds', mds)
addrs = status.get_mds_addrs(mds)
for addr in addrs:
ip_str, port_str = re.match("(.+):(.+)", addr).groups()
remote.run(
args=["sudo", "iptables", da_flag, "INPUT", "-p", "tcp", "--dport", port_str, "-j", "REJECT", "-m",
"comment", "--comment", "teuthology"])
mds = mds_ids[1]
remote = self.mon_manager.find_remote('mds', mds)
addrs = status.get_mds_addrs(mds)
for addr in addrs:
ip_str, port_str = re.match("(.+):(.+)", addr).groups()
remote.run(
args=["sudo", "iptables", da_flag, "OUTPUT", "-p", "tcp", "--sport", port_str, "-j", "REJECT", "-m",
"comment", "--comment", "teuthology"])
remote.run(
args=["sudo", "iptables", da_flag, "INPUT", "-p", "tcp", "--dport", port_str, "-j", "REJECT", "-m",
"comment", "--comment", "teuthology"])
self._one_or_all((mds_rank_1, mds_rank_2), set_block, in_parallel=False)
def clear_firewall(self):
clear_firewall(self._ctx)
def get_mds_info(self, mds_id):
return FSStatus(self.mon_manager).get_mds(mds_id)
def is_pool_full(self, pool_name):
pools = json.loads(self.mon_manager.raw_cluster_cmd("osd", "dump", "--format=json-pretty"))['pools']
for pool in pools:
if pool['pool_name'] == pool_name:
return 'full' in pool['flags_names'].split(",")
raise RuntimeError("Pool not found '{0}'".format(pool_name))
def delete_all_filesystems(self):
"""
Remove all filesystems that exist, and any pools in use by them.
"""
for fs in self.status().get_filesystems():
Filesystem(ctx=self._ctx, fscid=fs['id']).destroy()
class Filesystem(MDSCluster):
"""
This object is for driving a CephFS filesystem. The MDS daemons driven by
MDSCluster may be shared with other Filesystems.
"""
def __init__(self, ctx, fs_config={}, fscid=None, name=None, create=False):
super(Filesystem, self).__init__(ctx)
self.name = name
self.id = None
self.metadata_pool_name = None
self.metadata_overlay = False
self.data_pool_name = None
self.data_pools = None
self.fs_config = fs_config
self.ec_profile = fs_config.get('ec_profile')
client_list = list(misc.all_roles_of_type(self._ctx.cluster, 'client'))
self.client_id = client_list[0]
self.client_remote = list(misc.get_clients(ctx=ctx, roles=["client.{0}".format(self.client_id)]))[0][1]
if name is not None:
if fscid is not None:
raise RuntimeError("cannot specify fscid when creating fs")
if create and not self.legacy_configured():
self.create()
else:
if fscid is not None:
self.id = fscid
self.getinfo(refresh = True)
# Stash a reference to the first created filesystem on ctx, so
# that if someone drops to the interactive shell they can easily
# poke our methods.
if not hasattr(self._ctx, "filesystem"):
self._ctx.filesystem = self
def dead(self):
try:
return not bool(self.get_mds_map())
except FSMissing:
return True
def get_task_status(self, status_key):
return self.mon_manager.get_service_task_status("mds", status_key)
def getinfo(self, refresh = False):
status = self.status()
if self.id is not None:
fsmap = status.get_fsmap(self.id)
elif self.name is not None:
fsmap = status.get_fsmap_byname(self.name)
else:
fss = [fs for fs in status.get_filesystems()]
if len(fss) == 1:
fsmap = fss[0]
elif len(fss) == 0:
raise RuntimeError("no file system available")
else:
raise RuntimeError("more than one file system available")
self.id = fsmap['id']
self.name = fsmap['mdsmap']['fs_name']
self.get_pool_names(status = status, refresh = refresh)
return status
def set_metadata_overlay(self, overlay):
if self.id is not None:
raise RuntimeError("cannot specify fscid when configuring overlay")
self.metadata_overlay = overlay
def reach_max_mds(self):
status = self.wait_for_daemons()
mds_map = self.get_mds_map(status=status)
assert(mds_map['in'] == list(range(0, mds_map['max_mds'])))
def reset(self):
self.mon_manager.raw_cluster_cmd("fs", "reset", str(self.name), '--yes-i-really-mean-it')
def fail(self):
self.mon_manager.raw_cluster_cmd("fs", "fail", str(self.name))
def set_flag(self, var, *args):
a = map(lambda x: str(x).lower(), args)
self.mon_manager.raw_cluster_cmd("fs", "flag", "set", var, *a)
def set_allow_multifs(self, yes=True):
self.set_flag("enable_multiple", yes)
def set_var(self, var, *args):
a = map(lambda x: str(x).lower(), args)
self.mon_manager.raw_cluster_cmd("fs", "set", self.name, var, *a)
def set_down(self, down=True):
self.set_var("down", str(down).lower())
def set_joinable(self, joinable=True):
self.set_var("joinable", joinable)
def set_max_mds(self, max_mds):
self.set_var("max_mds", "%d" % max_mds)
def set_session_timeout(self, timeout):
self.set_var("session_timeout", "%d" % timeout)
def set_allow_standby_replay(self, yes):
self.set_var("allow_standby_replay", yes)
def set_allow_new_snaps(self, yes):
self.set_var("allow_new_snaps", yes, '--yes-i-really-mean-it')
def required_client_features(self, *args, **kwargs):
c = ["fs", "required_client_features", self.name, *args]
return self.mon_manager.run_cluster_cmd(args=c, **kwargs)
# In Octopus+, the PG count can be omitted to use the default. We keep the
# hard-coded value for deployments of Mimic/Nautilus.
pgs_per_fs_pool = 8
def create(self):
if self.name is None:
self.name = "cephfs"
if self.metadata_pool_name is None:
self.metadata_pool_name = "{0}_metadata".format(self.name)
if self.data_pool_name is None:
data_pool_name = "{0}_data".format(self.name)
else:
data_pool_name = self.data_pool_name
log.debug("Creating filesystem '{0}'".format(self.name))
self.mon_manager.raw_cluster_cmd('osd', 'pool', 'create',
self.metadata_pool_name, self.pgs_per_fs_pool.__str__())
self.mon_manager.raw_cluster_cmd('osd', 'pool', 'create',
data_pool_name, self.pgs_per_fs_pool.__str__())
if self.metadata_overlay:
self.mon_manager.raw_cluster_cmd('fs', 'new',
self.name, self.metadata_pool_name, data_pool_name,
'--allow-dangerous-metadata-overlay')
else:
self.mon_manager.raw_cluster_cmd('fs', 'new',
self.name,
self.metadata_pool_name,
data_pool_name)
if self.ec_profile and 'disabled' not in self.ec_profile:
ec_data_pool_name = data_pool_name + "_ec"
log.debug("EC profile is %s", self.ec_profile)
cmd = ['osd', 'erasure-code-profile', 'set', ec_data_pool_name]
cmd.extend(self.ec_profile)
self.mon_manager.raw_cluster_cmd(*cmd)
self.mon_manager.raw_cluster_cmd(
'osd', 'pool', 'create',
ec_data_pool_name, self.pgs_per_fs_pool.__str__(), 'erasure',
ec_data_pool_name)
self.mon_manager.raw_cluster_cmd(
'osd', 'pool', 'set',
ec_data_pool_name, 'allow_ec_overwrites', 'true')
self.add_data_pool(ec_data_pool_name, create=False)
self.check_pool_application(ec_data_pool_name)
self.run_client_payload(f"setfattr -n ceph.dir.layout.pool -v {ec_data_pool_name} . && getfattr -n ceph.dir.layout .")
self.check_pool_application(self.metadata_pool_name)
self.check_pool_application(data_pool_name)
# Turn off spurious standby count warnings from modifying max_mds in tests.
try:
self.mon_manager.raw_cluster_cmd('fs', 'set', self.name, 'standby_count_wanted', '0')
except CommandFailedError as e:
if e.exitstatus == 22:
# standby_count_wanted not available prior to luminous (upgrade tests would fail otherwise)
pass
else:
raise
if self.fs_config is not None:
max_mds = self.fs_config.get('max_mds', 1)
if max_mds > 1:
self.set_max_mds(max_mds)
standby_replay = self.fs_config.get('standby_replay', False)
self.set_allow_standby_replay(standby_replay)
# If absent will use the default value (60 seconds)
session_timeout = self.fs_config.get('session_timeout', 60)
if session_timeout != 60:
self.set_session_timeout(session_timeout)
self.getinfo(refresh = True)
def run_client_payload(self, cmd):
# avoid circular dep by importing here:
from tasks.cephfs.fuse_mount import FuseMount
d = misc.get_testdir(self._ctx)
m = FuseMount(self._ctx, {}, d, "admin", self.client_remote, cephfs_name=self.name)
m.mount_wait()
m.run_shell_payload(cmd)
m.umount_wait(require_clean=True)
def _remove_pool(self, name, **kwargs):
c = f'osd pool rm {name} {name} --yes-i-really-really-mean-it'
return self.mon_manager.ceph(c, **kwargs)
def rm(self, **kwargs):
c = f'fs rm {self.name} --yes-i-really-mean-it'
return self.mon_manager.ceph(c, **kwargs)
def remove_pools(self, data_pools):
self._remove_pool(self.get_metadata_pool_name())
for poolname in data_pools:
try:
self._remove_pool(poolname)
except CommandFailedError as e:
# EBUSY, this data pool is used by two metadata pools, let the
# 2nd pass delete it
if e.exitstatus == EBUSY:
pass
else:
raise
def destroy(self, reset_obj_attrs=True):
log.info(f'Destroying file system {self.name} and related pools')
if self.dead():
log.debug('already dead...')
return
data_pools = self.get_data_pool_names(refresh=True)
# make sure no MDSs are attached to given FS.
self.fail()
self.rm()
self.remove_pools(data_pools)
if reset_obj_attrs:
self.id = None
self.name = None
self.metadata_pool_name = None
self.data_pool_name = None
self.data_pools = None
def recreate(self):
self.destroy()
self.create()
self.getinfo(refresh=True)
def check_pool_application(self, pool_name):
osd_map = self.mon_manager.get_osd_dump_json()
for pool in osd_map['pools']:
if pool['pool_name'] == pool_name:
if "application_metadata" in pool:
if not "cephfs" in pool['application_metadata']:
raise RuntimeError("Pool {pool_name} does not name cephfs as application!".\
format(pool_name=pool_name))
def __del__(self):
if getattr(self._ctx, "filesystem", None) == self:
delattr(self._ctx, "filesystem")
def exists(self):
"""
Whether a filesystem exists in the mon's filesystem list
"""
fs_list = json.loads(self.mon_manager.raw_cluster_cmd('fs', 'ls', '--format=json-pretty'))
return self.name in [fs['name'] for fs in fs_list]
def legacy_configured(self):
"""
Check if a legacy (i.e. pre "fs new") filesystem configuration is present. If this is
the case, the caller should avoid using Filesystem.create
"""
try:
out_text = self.mon_manager.raw_cluster_cmd('--format=json-pretty', 'osd', 'lspools')
pools = json.loads(out_text)
metadata_pool_exists = 'metadata' in [p['poolname'] for p in pools]
if metadata_pool_exists:
self.metadata_pool_name = 'metadata'
except CommandFailedError as e:
# For use in upgrade tests, Ceph cuttlefish and earlier don't support
# structured output (--format) from the CLI.
if e.exitstatus == 22:
metadata_pool_exists = True
else:
raise
return metadata_pool_exists
def _df(self):
return json.loads(self.mon_manager.raw_cluster_cmd("df", "--format=json-pretty"))
# may raise FSMissing
def get_mds_map(self, status=None):
if status is None:
status = self.status()
return status.get_fsmap(self.id)['mdsmap']
def get_var(self, var, status=None):
return self.get_mds_map(status=status)[var]
def set_dir_layout(self, mount, path, layout):
for name, value in layout.items():
mount.run_shell(args=["setfattr", "-n", "ceph.dir.layout."+name, "-v", str(value), path])
def add_data_pool(self, name, create=True):
if create:
self.mon_manager.raw_cluster_cmd('osd', 'pool', 'create', name, self.pgs_per_fs_pool.__str__())
self.mon_manager.raw_cluster_cmd('fs', 'add_data_pool', self.name, name)
self.get_pool_names(refresh = True)
for poolid, fs_name in self.data_pools.items():
if name == fs_name:
return poolid
raise RuntimeError("could not get just created pool '{0}'".format(name))
def get_pool_names(self, refresh = False, status = None):
if refresh or self.metadata_pool_name is None or self.data_pools is None:
if status is None:
status = self.status()
fsmap = status.get_fsmap(self.id)
osd_map = self.mon_manager.get_osd_dump_json()
id_to_name = {}
for p in osd_map['pools']:
id_to_name[p['pool']] = p['pool_name']
self.metadata_pool_name = id_to_name[fsmap['mdsmap']['metadata_pool']]
self.data_pools = {}
for data_pool in fsmap['mdsmap']['data_pools']:
self.data_pools[data_pool] = id_to_name[data_pool]
def get_data_pool_name(self, refresh = False):
if refresh or self.data_pools is None:
self.get_pool_names(refresh = True)
assert(len(self.data_pools) == 1)
return next(iter(self.data_pools.values()))
def get_data_pool_id(self, refresh = False):
"""
Don't call this if you have multiple data pools
:return: integer
"""
if refresh or self.data_pools is None:
self.get_pool_names(refresh = True)
assert(len(self.data_pools) == 1)
return next(iter(self.data_pools.keys()))
def get_data_pool_names(self, refresh = False):
if refresh or self.data_pools is None:
self.get_pool_names(refresh = True)
return list(self.data_pools.values())
def get_metadata_pool_name(self):
return self.metadata_pool_name
def set_data_pool_name(self, name):
if self.id is not None:
raise RuntimeError("can't set filesystem name if its fscid is set")
self.data_pool_name = name
def get_namespace_id(self):
return self.id
def get_pool_df(self, pool_name):
"""
Return a dict like:
{u'bytes_used': 0, u'max_avail': 83848701, u'objects': 0, u'kb_used': 0}
"""
for pool_df in self._df()['pools']:
if pool_df['name'] == pool_name:
return pool_df['stats']
raise RuntimeError("Pool name '{0}' not found".format(pool_name))
def get_usage(self):
return self._df()['stats']['total_used_bytes']
def are_daemons_healthy(self, status=None, skip_max_mds_check=False):
"""
Return true if all daemons are in one of active, standby, standby-replay, and
at least max_mds daemons are in 'active'.
Unlike most of Filesystem, this function is tolerant of new-style `fs`
commands being missing, because we are part of the ceph installation
process during upgrade suites, so must fall back to old style commands
when we get an EINVAL on a new style command.
:return:
"""
# First, check to see that processes haven't exited with an error code
for mds in self._ctx.daemons.iter_daemons_of_role('mds'):
mds.check_status()
active_count = 0
mds_map = self.get_mds_map(status=status)
log.debug("are_daemons_healthy: mds map: {0}".format(mds_map))
for mds_id, mds_status in mds_map['info'].items():
if mds_status['state'] not in ["up:active", "up:standby", "up:standby-replay"]:
log.warning("Unhealthy mds state {0}:{1}".format(mds_id, mds_status['state']))
return False
elif mds_status['state'] == 'up:active':
active_count += 1
log.debug("are_daemons_healthy: {0}/{1}".format(
active_count, mds_map['max_mds']
))
if not skip_max_mds_check:
if active_count > mds_map['max_mds']:
log.debug("are_daemons_healthy: number of actives is greater than max_mds: {0}".format(mds_map))
return False
elif active_count == mds_map['max_mds']:
# The MDSMap says these guys are active, but let's check they really are
for mds_id, mds_status in mds_map['info'].items():
if mds_status['state'] == 'up:active':
try:
daemon_status = self.mds_tell(["status"], mds_id=mds_status['name'])
except CommandFailedError as cfe:
if cfe.exitstatus == errno.EINVAL:
# Old version, can't do this check
continue
else:
# MDS not even running
return False
if daemon_status['state'] != 'up:active':
# MDS hasn't taken the latest map yet
return False
return True
else:
return False
else:
log.debug("are_daemons_healthy: skipping max_mds check")
return True
def get_daemon_names(self, state=None, status=None):
"""
Return MDS daemon names of those daemons in the given state
:param state:
:return:
"""
mdsmap = self.get_mds_map(status)
result = []
for mds_status in sorted(mdsmap['info'].values(),
key=lambda _: _['rank']):
if mds_status['state'] == state or state is None:
result.append(mds_status['name'])
return result
def get_active_names(self, status=None):
"""
Return MDS daemon names of those daemons holding ranks
in state up:active
:return: list of strings like ['a', 'b'], sorted by rank
"""
return self.get_daemon_names("up:active", status=status)
def get_all_mds_rank(self, status=None):
mdsmap = self.get_mds_map(status)
result = []
for mds_status in sorted(mdsmap['info'].values(),
key=lambda _: _['rank']):
if mds_status['rank'] != -1 and mds_status['state'] != 'up:standby-replay':
result.append(mds_status['rank'])
return result
def get_rank(self, rank=None, status=None):
if status is None:
status = self.getinfo()
if rank is None:
rank = 0
return status.get_rank(self.id, rank)
def rank_restart(self, rank=0, status=None):
name = self.get_rank(rank=rank, status=status)['name']
self.mds_restart(mds_id=name)
def rank_signal(self, signal, rank=0, status=None):
name = self.get_rank(rank=rank, status=status)['name']
self.mds_signal(name, signal)
def rank_freeze(self, yes, rank=0):
self.mon_manager.raw_cluster_cmd("mds", "freeze", "{}:{}".format(self.id, rank), str(yes).lower())
def rank_fail(self, rank=0):
self.mon_manager.raw_cluster_cmd("mds", "fail", "{}:{}".format(self.id, rank))
def get_ranks(self, status=None):
if status is None:
status = self.getinfo()
return status.get_ranks(self.id)
def get_replays(self, status=None):
if status is None:
status = self.getinfo()
return status.get_replays(self.id)
def get_replay(self, rank=0, status=None):
for replay in self.get_replays(status=status):
if replay['rank'] == rank:
return replay
return None
def get_rank_names(self, status=None):
"""
Return MDS daemon names of those daemons holding a rank,
sorted by rank. This includes e.g. up:replay/reconnect
as well as active, but does not include standby or
standby-replay.
"""
mdsmap = self.get_mds_map(status)
result = []
for mds_status in sorted(mdsmap['info'].values(),
key=lambda _: _['rank']):
if mds_status['rank'] != -1 and mds_status['state'] != 'up:standby-replay':
result.append(mds_status['name'])
return result
def wait_for_daemons(self, timeout=None, skip_max_mds_check=False, status=None):
"""