]>
Commit | Line | Data |
---|---|---|
11fdf7f2 | 1 | # -*- coding: utf-8 -*- |
9f95a23c | 2 | # pylint: disable=unused-argument |
11fdf7f2 TL |
3 | from __future__ import absolute_import |
4 | ||
5 | import six | |
6 | ||
9f95a23c TL |
7 | import cherrypy |
8 | ||
11fdf7f2 TL |
9 | import rbd |
10 | ||
11 | from .. import mgr | |
9f95a23c TL |
12 | from ..tools import ViewCache |
13 | from .ceph_service import CephService | |
14 | ||
15 | try: | |
16 | from typing import List | |
17 | except ImportError: | |
18 | pass # For typing only | |
11fdf7f2 TL |
19 | |
20 | ||
21 | RBD_FEATURES_NAME_MAPPING = { | |
22 | rbd.RBD_FEATURE_LAYERING: "layering", | |
23 | rbd.RBD_FEATURE_STRIPINGV2: "striping", | |
24 | rbd.RBD_FEATURE_EXCLUSIVE_LOCK: "exclusive-lock", | |
25 | rbd.RBD_FEATURE_OBJECT_MAP: "object-map", | |
26 | rbd.RBD_FEATURE_FAST_DIFF: "fast-diff", | |
27 | rbd.RBD_FEATURE_DEEP_FLATTEN: "deep-flatten", | |
28 | rbd.RBD_FEATURE_JOURNALING: "journaling", | |
29 | rbd.RBD_FEATURE_DATA_POOL: "data-pool", | |
30 | rbd.RBD_FEATURE_OPERATIONS: "operations", | |
31 | } | |
32 | ||
33 | ||
34 | def format_bitmask(features): | |
35 | """ | |
36 | Formats the bitmask: | |
37 | ||
9f95a23c | 38 | @DISABLEDOCTEST: >>> format_bitmask(45) |
11fdf7f2 TL |
39 | ['deep-flatten', 'exclusive-lock', 'layering', 'object-map'] |
40 | """ | |
41 | names = [val for key, val in RBD_FEATURES_NAME_MAPPING.items() | |
42 | if key & features == key] | |
43 | return sorted(names) | |
44 | ||
45 | ||
46 | def format_features(features): | |
47 | """ | |
48 | Converts the features list to bitmask: | |
49 | ||
9f95a23c TL |
50 | @DISABLEDOCTEST: >>> format_features(['deep-flatten', 'exclusive-lock', |
51 | 'layering', 'object-map']) | |
11fdf7f2 TL |
52 | 45 |
53 | ||
9f95a23c | 54 | @DISABLEDOCTEST: >>> format_features(None) is None |
11fdf7f2 TL |
55 | True |
56 | ||
9f95a23c | 57 | @DISABLEDOCTEST: >>> format_features('deep-flatten, exclusive-lock') |
11fdf7f2 TL |
58 | 32 |
59 | """ | |
60 | if isinstance(features, six.string_types): | |
61 | features = features.split(',') | |
62 | ||
63 | if not isinstance(features, list): | |
64 | return None | |
65 | ||
66 | res = 0 | |
67 | for key, value in RBD_FEATURES_NAME_MAPPING.items(): | |
68 | if value in features: | |
69 | res = key | res | |
70 | return res | |
71 | ||
72 | ||
9f95a23c TL |
73 | def get_image_spec(pool_name, namespace, rbd_name): |
74 | namespace = '{}/'.format(namespace) if namespace else '' | |
75 | return '{}/{}{}'.format(pool_name, namespace, rbd_name) | |
76 | ||
77 | ||
78 | def parse_image_spec(image_spec): | |
79 | namespace_spec, image_name = image_spec.rsplit('/', 1) | |
80 | if '/' in namespace_spec: | |
81 | pool_name, namespace = namespace_spec.rsplit('/', 1) | |
82 | else: | |
83 | pool_name, namespace = namespace_spec, None | |
84 | return pool_name, namespace, image_name | |
85 | ||
86 | ||
87 | def rbd_call(pool_name, namespace, func, *args, **kwargs): | |
88 | with mgr.rados.open_ioctx(pool_name) as ioctx: | |
89 | ioctx.set_namespace(namespace if namespace is not None else '') | |
90 | func(ioctx, *args, **kwargs) | |
91 | ||
92 | ||
93 | def rbd_image_call(pool_name, namespace, image_name, func, *args, **kwargs): | |
94 | def _ioctx_func(ioctx, image_name, func, *args, **kwargs): | |
95 | with rbd.Image(ioctx, image_name) as img: | |
96 | func(ioctx, img, *args, **kwargs) | |
97 | ||
98 | return rbd_call(pool_name, namespace, _ioctx_func, image_name, func, *args, **kwargs) | |
99 | ||
100 | ||
11fdf7f2 TL |
101 | class RbdConfiguration(object): |
102 | _rbd = rbd.RBD() | |
103 | ||
9f95a23c TL |
104 | def __init__(self, pool_name='', namespace='', image_name='', pool_ioctx=None, |
105 | image_ioctx=None): | |
106 | # type: (str, str, str, object, object) -> None | |
11fdf7f2 TL |
107 | assert bool(pool_name) != bool(pool_ioctx) # xor |
108 | self._pool_name = pool_name | |
9f95a23c | 109 | self._namespace = namespace if namespace is not None else '' |
11fdf7f2 TL |
110 | self._image_name = image_name |
111 | self._pool_ioctx = pool_ioctx | |
112 | self._image_ioctx = image_ioctx | |
113 | ||
114 | @staticmethod | |
115 | def _ensure_prefix(option): | |
116 | # type: (str) -> str | |
117 | return option if option.startswith('conf_') else 'conf_' + option | |
118 | ||
119 | def list(self): | |
9f95a23c | 120 | # type: () -> List[dict] |
11fdf7f2 TL |
121 | def _list(ioctx): |
122 | if self._image_name: # image config | |
9f95a23c TL |
123 | try: |
124 | with rbd.Image(ioctx, self._image_name) as image: | |
125 | result = image.config_list() | |
126 | except rbd.ImageNotFound: | |
127 | result = [] | |
11fdf7f2 | 128 | else: # pool config |
e306af50 TL |
129 | pg_status = list(CephService.get_pool_pg_status(self._pool_name).keys()) |
130 | if len(pg_status) == 1 and 'incomplete' in pg_status[0]: | |
131 | # If config_list would be called with ioctx if it's a bad pool, | |
132 | # the dashboard would stop working, waiting for the response | |
133 | # that would not happen. | |
134 | # | |
135 | # This is only a workaround for https://tracker.ceph.com/issues/43771 which | |
136 | # already got rejected as not worth the effort. | |
137 | # | |
138 | # Are more complete workaround for the dashboard will be implemented with | |
139 | # https://tracker.ceph.com/issues/44224 | |
140 | # | |
141 | # @TODO: If #44224 is addressed remove this workaround | |
142 | return [] | |
11fdf7f2 TL |
143 | result = self._rbd.config_list(ioctx) |
144 | return list(result) | |
145 | ||
146 | if self._pool_name: | |
147 | ioctx = mgr.rados.open_ioctx(self._pool_name) | |
9f95a23c | 148 | ioctx.set_namespace(self._namespace) |
11fdf7f2 TL |
149 | else: |
150 | ioctx = self._pool_ioctx | |
151 | ||
152 | return _list(ioctx) | |
153 | ||
154 | def get(self, option_name): | |
155 | # type: (str) -> str | |
156 | option_name = self._ensure_prefix(option_name) | |
157 | with mgr.rados.open_ioctx(self._pool_name) as pool_ioctx: | |
9f95a23c | 158 | pool_ioctx.set_namespace(self._namespace) |
11fdf7f2 TL |
159 | if self._image_name: |
160 | with rbd.Image(pool_ioctx, self._image_name) as image: | |
161 | return image.metadata_get(option_name) | |
162 | return self._rbd.pool_metadata_get(pool_ioctx, option_name) | |
163 | ||
164 | def set(self, option_name, option_value): | |
165 | # type: (str, str) -> None | |
166 | ||
167 | option_value = str(option_value) | |
168 | option_name = self._ensure_prefix(option_name) | |
169 | ||
170 | pool_ioctx = self._pool_ioctx | |
171 | if self._pool_name: # open ioctx | |
172 | pool_ioctx = mgr.rados.open_ioctx(self._pool_name) | |
9f95a23c TL |
173 | pool_ioctx.__enter__() # type: ignore |
174 | pool_ioctx.set_namespace(self._namespace) # type: ignore | |
11fdf7f2 TL |
175 | |
176 | image_ioctx = self._image_ioctx | |
177 | if self._image_name: | |
178 | image_ioctx = rbd.Image(pool_ioctx, self._image_name) | |
9f95a23c | 179 | image_ioctx.__enter__() # type: ignore |
11fdf7f2 TL |
180 | |
181 | if image_ioctx: | |
9f95a23c | 182 | image_ioctx.metadata_set(option_name, option_value) # type: ignore |
11fdf7f2 TL |
183 | else: |
184 | self._rbd.pool_metadata_set(pool_ioctx, option_name, option_value) | |
185 | ||
186 | if self._image_name: # Name provided, so we opened it and now have to close it | |
9f95a23c | 187 | image_ioctx.__exit__(None, None, None) # type: ignore |
11fdf7f2 | 188 | if self._pool_name: |
9f95a23c | 189 | pool_ioctx.__exit__(None, None, None) # type: ignore |
11fdf7f2 TL |
190 | |
191 | def remove(self, option_name): | |
192 | """ | |
193 | Removes an option by name. Will not raise an error, if the option hasn't been found. | |
194 | :type option_name str | |
195 | """ | |
196 | def _remove(ioctx): | |
197 | try: | |
198 | if self._image_name: | |
199 | with rbd.Image(ioctx, self._image_name) as image: | |
200 | image.metadata_remove(option_name) | |
201 | else: | |
202 | self._rbd.pool_metadata_remove(ioctx, option_name) | |
203 | except KeyError: | |
204 | pass | |
205 | ||
206 | option_name = self._ensure_prefix(option_name) | |
207 | ||
208 | if self._pool_name: | |
209 | with mgr.rados.open_ioctx(self._pool_name) as pool_ioctx: | |
9f95a23c | 210 | pool_ioctx.set_namespace(self._namespace) |
11fdf7f2 TL |
211 | _remove(pool_ioctx) |
212 | else: | |
213 | _remove(self._pool_ioctx) | |
214 | ||
215 | def set_configuration(self, configuration): | |
216 | if configuration: | |
217 | for option_name, option_value in configuration.items(): | |
218 | if option_value is not None: | |
219 | self.set(option_name, option_value) | |
220 | else: | |
221 | self.remove(option_name) | |
9f95a23c TL |
222 | |
223 | ||
224 | class RbdService(object): | |
225 | ||
226 | @classmethod | |
227 | def _rbd_disk_usage(cls, image, snaps, whole_object=True): | |
228 | class DUCallback(object): | |
229 | def __init__(self): | |
230 | self.used_size = 0 | |
231 | ||
232 | def __call__(self, offset, length, exists): | |
233 | if exists: | |
234 | self.used_size += length | |
235 | ||
236 | snap_map = {} | |
237 | prev_snap = None | |
238 | total_used_size = 0 | |
239 | for _, size, name in snaps: | |
240 | image.set_snap(name) | |
241 | du_callb = DUCallback() | |
242 | image.diff_iterate(0, size, prev_snap, du_callb, | |
243 | whole_object=whole_object) | |
244 | snap_map[name] = du_callb.used_size | |
245 | total_used_size += du_callb.used_size | |
246 | prev_snap = name | |
247 | ||
248 | return total_used_size, snap_map | |
249 | ||
250 | @classmethod | |
251 | def _rbd_image(cls, ioctx, pool_name, namespace, image_name): | |
252 | with rbd.Image(ioctx, image_name) as img: | |
253 | ||
254 | stat = img.stat() | |
255 | stat['name'] = image_name | |
256 | stat['id'] = img.id() | |
257 | stat['pool_name'] = pool_name | |
258 | stat['namespace'] = namespace | |
259 | features = img.features() | |
260 | stat['features'] = features | |
261 | stat['features_name'] = format_bitmask(features) | |
262 | ||
263 | # the following keys are deprecated | |
264 | del stat['parent_pool'] | |
265 | del stat['parent_name'] | |
266 | ||
267 | stat['timestamp'] = "{}Z".format(img.create_timestamp() | |
268 | .isoformat()) | |
269 | ||
270 | stat['stripe_count'] = img.stripe_count() | |
271 | stat['stripe_unit'] = img.stripe_unit() | |
272 | ||
273 | data_pool_name = CephService.get_pool_name_from_id( | |
274 | img.data_pool_id()) | |
275 | if data_pool_name == pool_name: | |
276 | data_pool_name = None | |
277 | stat['data_pool'] = data_pool_name | |
278 | ||
279 | try: | |
280 | stat['parent'] = img.get_parent_image_spec() | |
281 | except rbd.ImageNotFound: | |
282 | # no parent image | |
283 | stat['parent'] = None | |
284 | ||
285 | # snapshots | |
286 | stat['snapshots'] = [] | |
287 | for snap in img.list_snaps(): | |
288 | snap['timestamp'] = "{}Z".format( | |
289 | img.get_snap_timestamp(snap['id']).isoformat()) | |
290 | snap['is_protected'] = img.is_protected_snap(snap['name']) | |
291 | snap['used_bytes'] = None | |
292 | snap['children'] = [] | |
293 | img.set_snap(snap['name']) | |
294 | for child_pool_name, child_image_name in img.list_children(): | |
295 | snap['children'].append({ | |
296 | 'pool_name': child_pool_name, | |
297 | 'image_name': child_image_name | |
298 | }) | |
299 | stat['snapshots'].append(snap) | |
300 | ||
301 | # disk usage | |
302 | img_flags = img.flags() | |
303 | if 'fast-diff' in stat['features_name'] and \ | |
304 | not rbd.RBD_FLAG_FAST_DIFF_INVALID & img_flags: | |
305 | snaps = [(s['id'], s['size'], s['name']) | |
306 | for s in stat['snapshots']] | |
307 | snaps.sort(key=lambda s: s[0]) | |
308 | snaps += [(snaps[-1][0] + 1 if snaps else 0, stat['size'], None)] | |
309 | total_prov_bytes, snaps_prov_bytes = cls._rbd_disk_usage( | |
310 | img, snaps, True) | |
311 | stat['total_disk_usage'] = total_prov_bytes | |
312 | for snap, prov_bytes in snaps_prov_bytes.items(): | |
313 | if snap is None: | |
314 | stat['disk_usage'] = prov_bytes | |
315 | continue | |
316 | for ss in stat['snapshots']: | |
317 | if ss['name'] == snap: | |
318 | ss['disk_usage'] = prov_bytes | |
319 | break | |
320 | else: | |
321 | stat['total_disk_usage'] = None | |
322 | stat['disk_usage'] = None | |
323 | ||
324 | stat['configuration'] = RbdConfiguration(pool_ioctx=ioctx, image_name=image_name).list() | |
325 | ||
326 | return stat | |
327 | ||
328 | @classmethod | |
329 | def _rbd_image_names(cls, ioctx): | |
330 | rbd_inst = rbd.RBD() | |
331 | return rbd_inst.list(ioctx) | |
332 | ||
333 | @classmethod | |
334 | def _rbd_image_stat(cls, ioctx, pool_name, namespace, image_name): | |
335 | return cls._rbd_image(ioctx, pool_name, namespace, image_name) | |
336 | ||
337 | @classmethod | |
338 | @ViewCache() | |
339 | def rbd_pool_list(cls, pool_name, namespace=None): | |
340 | rbd_inst = rbd.RBD() | |
341 | with mgr.rados.open_ioctx(pool_name) as ioctx: | |
342 | result = [] | |
343 | if namespace: | |
344 | namespaces = [namespace] | |
345 | else: | |
346 | namespaces = rbd_inst.namespace_list(ioctx) | |
347 | # images without namespace | |
348 | namespaces.append('') | |
349 | for current_namespace in namespaces: | |
350 | ioctx.set_namespace(current_namespace) | |
351 | names = cls._rbd_image_names(ioctx) | |
352 | for name in names: | |
353 | try: | |
354 | stat = cls._rbd_image_stat(ioctx, pool_name, current_namespace, name) | |
355 | except rbd.ImageNotFound: | |
356 | # may have been removed in the meanwhile | |
357 | continue | |
358 | result.append(stat) | |
359 | return result | |
360 | ||
361 | @classmethod | |
362 | def get_image(cls, image_spec): | |
363 | pool_name, namespace, image_name = parse_image_spec(image_spec) | |
364 | ioctx = mgr.rados.open_ioctx(pool_name) | |
365 | if namespace: | |
366 | ioctx.set_namespace(namespace) | |
367 | try: | |
368 | return cls._rbd_image(ioctx, pool_name, namespace, image_name) | |
369 | except rbd.ImageNotFound: | |
370 | raise cherrypy.HTTPError(404, 'Image not found') | |
371 | ||
372 | ||
373 | class RbdSnapshotService(object): | |
374 | ||
375 | @classmethod | |
376 | def remove_snapshot(cls, image_spec, snapshot_name, unprotect=False): | |
377 | def _remove_snapshot(ioctx, img, snapshot_name, unprotect): | |
378 | if unprotect: | |
379 | img.unprotect_snap(snapshot_name) | |
380 | img.remove_snap(snapshot_name) | |
381 | ||
382 | pool_name, namespace, image_name = parse_image_spec(image_spec) | |
383 | return rbd_image_call(pool_name, namespace, image_name, | |
384 | _remove_snapshot, snapshot_name, unprotect) |