{
"size": 1073741824,
"obj_size": 4194304,
+ "mirror_mode": "journal",
"num_objs": 256,
"order": 22,
"block_name_prefix": "rbd_data.10ae2ae8944a",
'source': JLeaf(int),
'value': JLeaf(str),
})),
+ 'mirror_mode': JLeaf(str),
})
self.assertSchema(img, schema)
os.path.dirname(__file__),
'frontend/dist'))
+ import rbd
+
+ # Api tests do not mock rbd as opposed to dashboard unit tests. Both
+ # use UNITTEST env variable.
+ if isinstance(rbd, mock.Mock):
+ rbd.RBD_MIRROR_IMAGE_MODE_JOURNAL = 0
+ rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT = 1
+
# DO NOT REMOVE: required for ceph-mgr to load a module
from .module import Module, StandbyModule # noqa: F401
import logging
import math
from datetime import datetime
-from enum import Enum
from functools import partial
import rbd
from ..security import Scope
from ..services.ceph_service import CephService
from ..services.exception import handle_rados_error, handle_rbd_error, serialize_dashboard_exception
-from ..services.rbd import RbdConfiguration, RbdMirroringService, RbdService, \
- RbdSnapshotService, format_bitmask, format_features, parse_image_spec, \
- rbd_call, rbd_image_call
+from ..services.rbd import MIRROR_IMAGE_MODE, RbdConfiguration, \
+ RbdMirroringService, RbdService, RbdSnapshotService, format_bitmask, \
+ format_features, get_image_spec, parse_image_spec, rbd_call, \
+ rbd_image_call
from ..tools import ViewCache, str_to_bool
from . import APIDoc, APIRouter, CreatePermission, DeletePermission, \
EndpointDoc, RESTController, Task, UpdatePermission, allow_empty_body
ALLOW_DISABLE_FEATURES = {"exclusive-lock", "object-map", "fast-diff", "deep-flatten",
"journaling"}
- class MIRROR_IMAGE_MODE(Enum):
- journal = rbd.RBD_MIRROR_IMAGE_MODE_JOURNAL
- snapshot = rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT
-
def _rbd_list(self, pool_name=None):
if pool_name:
pools = [pool_name]
@RbdTask('create',
{'pool_name': '{pool_name}', 'namespace': '{namespace}', 'image_name': '{name}'}, 2.0)
- def create(self, name, pool_name, size, namespace=None, obj_size=None, features=None,
- stripe_unit=None, stripe_count=None, data_pool=None, configuration=None):
+ def create(self, name, pool_name, size, namespace=None, schedule_interval='',
+ obj_size=None, features=None, stripe_unit=None, stripe_count=None,
+ data_pool=None, configuration=None, mirror_mode=None):
size = int(size)
image_name=name).set_configuration(configuration)
rbd_call(pool_name, namespace, _create)
+ if mirror_mode:
+ RbdMirroringService.enable_image(name, pool_name, namespace,
+ MIRROR_IMAGE_MODE[mirror_mode])
+
+ if schedule_interval:
+ image_spec = get_image_spec(pool_name, namespace, name)
+ RbdMirroringService.snapshot_schedule_add(image_spec, schedule_interval)
@RbdTask('delete', ['{image_spec}'], 2.0)
def delete(self, image_spec):
@RbdTask('edit', ['{image_spec}', '{name}'], 4.0)
def set(self, image_spec, name=None, size=None, features=None,
configuration=None, enable_mirror=None, primary=None,
- resync=False, mirror_mode=None, schedule_interval='', start_time=''):
+ resync=False, mirror_mode=None, schedule_interval='',
+ remove_scheduling=False):
+
pool_name, namespace, image_name = parse_image_spec(image_spec)
def _edit(ioctx, image):
if enable_mirror and mirror_image_info['state'] == rbd.RBD_MIRROR_IMAGE_DISABLED:
RbdMirroringService.enable_image(
image_name, pool_name, namespace,
- self.MIRROR_IMAGE_MODE[mirror_mode].value)
+ MIRROR_IMAGE_MODE[mirror_mode])
elif (enable_mirror is False
and mirror_image_info['state'] == rbd.RBD_MIRROR_IMAGE_ENABLED):
RbdMirroringService.disable_image(
RbdMirroringService.resync_image(image_name, pool_name, namespace)
if schedule_interval:
- RbdMirroringService.snapshot_schedule(image_spec, schedule_interval, start_time)
+ RbdMirroringService.snapshot_schedule_add(image_spec, schedule_interval)
+
+ if remove_scheduling:
+ RbdMirroringService.snapshot_schedule_remove(image_spec)
return rbd_image_call(pool_name, namespace, image_name, _edit)
import { IscsiComponent } from './iscsi/iscsi.component';
import { MirroringModule } from './mirroring/mirroring.module';
import { OverviewComponent as RbdMirroringComponent } from './mirroring/overview/overview.component';
+import { PoolEditModeModalComponent } from './mirroring/pool-edit-mode-modal/pool-edit-mode-modal.component';
import { RbdConfigurationFormComponent } from './rbd-configuration-form/rbd-configuration-form.component';
import { RbdConfigurationListComponent } from './rbd-configuration-list/rbd-configuration-list.component';
import { RbdDetailsComponent } from './rbd-details/rbd-details.component';
path: 'mirroring',
component: RbdMirroringComponent,
canActivate: [FeatureTogglesGuardService],
- data: { breadcrumbs: 'Mirroring' }
+ data: { breadcrumbs: 'Mirroring' },
+ children: [
+ {
+ path: `${URLVerbs.EDIT}/:pool_name`,
+ component: PoolEditModeModalComponent,
+ outlet: 'modal'
+ }
+ ]
},
// iSCSI
{
-<cd-modal [modalRef]="activeModal">
+<cd-modal [modalRef]="activeModal"
+ pageURL="mirroring">
<ng-container i18n
class="modal-title">Edit pool mirror mode</ng-container>
import { HttpClientTestingModule } from '@angular/common/http/testing';
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { ReactiveFormsModule } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
import { RouterTestingModule } from '@angular/router/testing';
import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
import { RbdMirroringService } from '~/app/shared/api/rbd-mirroring.service';
import { NotificationService } from '~/app/shared/services/notification.service';
import { SharedModule } from '~/app/shared/shared.module';
+import { ActivatedRouteStub } from '~/testing/activated-route-stub';
import { configureTestBed, FormHelper } from '~/testing/unit-test-helper';
import { PoolEditModeModalComponent } from './pool-edit-mode-modal.component';
let notificationService: NotificationService;
let rbdMirroringService: RbdMirroringService;
let formHelper: FormHelper;
+ let activatedRoute: ActivatedRouteStub;
configureTestBed({
declarations: [PoolEditModeModalComponent],
SharedModule,
ToastrModule.forRoot()
],
- providers: [NgbActiveModal]
+ providers: [
+ NgbActiveModal,
+ {
+ provide: ActivatedRoute,
+ useValue: new ActivatedRouteStub({ pool_name: 'somePool' })
+ }
+ ]
});
beforeEach(() => {
spyOn(notificationService, 'show').and.stub();
rbdMirroringService = TestBed.inject(RbdMirroringService);
+ activatedRoute = <ActivatedRouteStub>TestBed.inject(ActivatedRoute);
formHelper = new FormHelper(component.editModeForm);
fixture.detectChanges();
spyOn(component.activeModal, 'close').and.callThrough();
});
- afterEach(() => {
- expect(component.activeModal.close).toHaveBeenCalledTimes(1);
- });
-
it('should call updatePool', () => {
+ activatedRoute.setParams({ pool_name: 'somePool' });
spyOn(rbdMirroringService, 'updatePool').and.callFake(() => of(''));
component.editModeForm.patchValue({ mirrorMode: 'disabled' });
+import { Location } from '@angular/common';
import { Component, OnDestroy, OnInit } from '@angular/core';
import { AbstractControl, FormControl, Validators } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
import { Subscription } from 'rxjs';
public activeModal: NgbActiveModal,
public actionLabels: ActionLabelsI18n,
private rbdMirroringService: RbdMirroringService,
- private taskWrapper: TaskWrapperService
+ private taskWrapper: TaskWrapperService,
+ private route: ActivatedRoute,
+ private location: Location
) {
this.createForm();
}
}
ngOnInit() {
+ this.route.params.subscribe((params: { pool_name: string }) => {
+ this.poolName = params.pool_name;
+ });
this.pattern = `${this.poolName}`;
this.rbdMirroringService.getPool(this.poolName).subscribe((resp: PoolEditModeResponseModel) => {
this.setResponse(resp);
error: () => this.editModeForm.setErrors({ cdSubmitButton: true }),
complete: () => {
this.rbdMirroringService.refresh();
- this.activeModal.close();
+ this.location.back();
}
});
}
let-value="value">
<span [ngClass]="row.health_color | mirrorHealthColor">{{ value }}</span>
</ng-template>
+<router-outlet name="modal"></router-outlet>
import { Component, OnDestroy, OnInit, TemplateRef, ViewChild } from '@angular/core';
+import { Router } from '@angular/router';
import { NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
import { Observable, Subscriber, Subscription } from 'rxjs';
import { RbdMirroringService } from '~/app/shared/api/rbd-mirroring.service';
import { TableStatusViewCache } from '~/app/shared/classes/table-status-view-cache';
import { CriticalConfirmationModalComponent } from '~/app/shared/components/critical-confirmation-modal/critical-confirmation-modal.component';
+import { URLVerbs } from '~/app/shared/constants/app.constants';
import { Icons } from '~/app/shared/enum/icons.enum';
import { CdTableAction } from '~/app/shared/models/cd-table-action';
import { CdTableSelection } from '~/app/shared/models/cd-table-selection';
import { AuthStorageService } from '~/app/shared/services/auth-storage.service';
import { ModalService } from '~/app/shared/services/modal.service';
import { TaskWrapperService } from '~/app/shared/services/task-wrapper.service';
-import { PoolEditModeModalComponent } from '../pool-edit-mode-modal/pool-edit-mode-modal.component';
import { PoolEditPeerModalComponent } from '../pool-edit-peer-modal/pool-edit-peer-modal.component';
+const BASE_URL = '/block/mirroring';
@Component({
selector: 'cd-mirroring-pools',
templateUrl: './pool-list.component.html',
private authStorageService: AuthStorageService,
private rbdMirroringService: RbdMirroringService,
private modalService: ModalService,
- private taskWrapper: TaskWrapperService
+ private taskWrapper: TaskWrapperService,
+ private router: Router
) {
this.data = [];
this.permission = this.authStorageService.getPermissions().rbdMirroring;
}
editModeModal() {
- const initialState = {
- poolName: this.selection.first().name
- };
- this.modalRef = this.modalService.show(PoolEditModeModalComponent, initialState);
+ this.router.navigate([
+ BASE_URL,
+ { outlets: { modal: [URLVerbs.EDIT, this.selection.first().name] } }
+ ]);
}
editPeersModal(mode: string) {
[featuresName]="selection.features_name"
[poolName]="selection.pool_name"
[namespace]="selection.namespace"
+ [mirroring]="selection.mirror_mode"
[rbdName]="selection.name"></cd-rbd-snapshot-list>
</ng-template>
</li>
size: number;
features: Array<string> = [];
configuration: RbdConfigurationEntry[];
+
+ enable_mirror?: boolean;
+ mirror_mode?: string;
+ schedule_interval: string;
+ remove_scheduling? = false;
}
name="pool"
class="form-control"
formControlName="pool"
- *ngIf="mode !== 'editing' && poolPermission.read">
+ *ngIf="mode !== 'editing' && poolPermission.read"
+ (change)="setPoolMirrorMode()">
<option *ngIf="pools === null"
[ngValue]="null"
i18n>Loading...</option>
</div>
</div>
+ <!-- Mirroring -->
+ <div class="form-group row">
+ <div class="cd-col-form-offset">
+ <div class="custom-control custom-checkbox">
+ <input type="checkbox"
+ class="custom-control-input"
+ id="mirroring"
+ name="mirroring"
+ (change)="setMirrorMode()"
+ formControlName="mirroring">
+ <label class="custom-control-label"
+ for="mirroring">Mirroring</label>
+ <cd-helper *ngIf="mirroring === false && this.currentPoolName">
+ <span i18n>You need to enable a <b>mirror mode</b> in the selected pool. Please <a [routerLink]="['/block/mirroring', {outlets: {modal: ['edit', currentPoolName]}}]">click here to select a mode and enable it in this pool.</a></span>
+ </cd-helper>
+ </div>
+ <div *ngIf="mirroring">
+ <div class="custom-control custom-radio ml-2"
+ *ngFor="let option of mirroringOptions">
+ <input type="radio"
+ class="custom-control-input"
+ [id]="option"
+ [value]="option"
+ name="mirroringMode"
+ (change)="setExclusiveLock()"
+ formControlName="mirroringMode"
+ [attr.disabled]="(poolMirrorMode === 'pool' && option === 'snapshot') ? true : null">
+ <label class="custom-control-label"
+ [for]="option">{{ option | titlecase }}</label>
+ <cd-helper *ngIf="poolMirrorMode === 'pool' && option === 'snapshot'">
+ <span i18n>You need to enable <b>image mirror mode</b> in the selected pool. Please <a [routerLink]="['/block/mirroring', {outlets: {modal: ['edit', currentPoolName]}}]">click here to select a mode and enable it in this pool.</a></span>
+ </cd-helper>
+ </div>
+ </div>
+ </div>
+ </div>
+
+ <div class="form-group row"
+ *ngIf="rbdForm.getValue('mirroringMode') === 'snapshot' && mirroring">
+ <label class="cd-col-form-label"
+ i18n>Schedule Interval
+ <cd-helper i18n-html
+ html="Create Mirror-Snapshots automatically on a periodic basis. The interval can be specified in days, hours, or minutes using d, h, m suffix respectively.">
+ </cd-helper></label>
+ <div class="cd-col-form-input">
+ <input id="schedule"
+ name="schedule"
+ class="form-control"
+ type="text"
+ formControlName="schedule"
+ i18n-placeholder
+ placeholder="e.g., 12h or 1d or 10m"
+ [attr.disabled]="(mode === rbdFormMode.editing) ? true : null">
+ </div>
+ </div>
+
<!-- Advanced -->
<div class="row">
<div class="col-sm-12">
});
describe('tests for feature flags', () => {
- let deepFlatten: any,
- layering: any,
- exclusiveLock: any,
- objectMap: any,
- journaling: any,
- fastDiff: any;
+ let deepFlatten: any, layering: any, exclusiveLock: any, objectMap: any, fastDiff: any;
const defaultFeatures = [
// Supposed to be enabled by default
'deep-flatten',
'layering',
'exclusive-lock',
'object-map',
- 'journaling',
'fast-diff'
];
const setFeatures = (features: Record<string, RbdImageFeature>) => {
spyOn(rbdService, 'defaultFeatures').and.returnValue(of(defaultFeatures));
setRouterUrl('edit', pool, image);
fixture.detectChanges();
- [
- deepFlatten,
- layering,
- exclusiveLock,
- objectMap,
- journaling,
- fastDiff
- ] = getFeatureNativeElements();
+ [deepFlatten, layering, exclusiveLock, objectMap, fastDiff] = getFeatureNativeElements();
};
it('should have the interlock feature for flags disabled, if one feature is not set', () => {
spyOn(rbdService, 'defaultFeatures').and.returnValue(of(defaultFeatures));
setRouterUrl('create');
fixture.detectChanges();
- [
- deepFlatten,
- layering,
- exclusiveLock,
- objectMap,
- journaling,
- fastDiff
- ] = getFeatureNativeElements();
+ [deepFlatten, layering, exclusiveLock, objectMap, fastDiff] = getFeatureNativeElements();
});
it('should initialize the checkboxes correctly', () => {
expect(layering.disabled).toBe(false);
expect(exclusiveLock.disabled).toBe(false);
expect(objectMap.disabled).toBe(false);
- expect(journaling.disabled).toBe(false);
expect(fastDiff.disabled).toBe(false);
expect(deepFlatten.checked).toBe(true);
expect(layering.checked).toBe(true);
expect(exclusiveLock.checked).toBe(true);
expect(objectMap.checked).toBe(true);
- expect(journaling.checked).toBe(false);
expect(fastDiff.checked).toBe(true);
});
it('should disable features if their requirements are not met (exclusive-lock)', () => {
exclusiveLock.click(); // unchecks exclusive-lock
expect(objectMap.disabled).toBe(true);
- expect(journaling.disabled).toBe(true);
expect(fastDiff.disabled).toBe(true);
});
expect(fastDiff.disabled).toBe(true);
});
});
+
+ describe('test mirroring options', () => {
+ beforeEach(() => {
+ component.ngOnInit();
+ fixture.detectChanges();
+ const mirroring = fixture.debugElement.query(By.css('#mirroring')).nativeElement;
+ mirroring.click();
+ fixture.detectChanges();
+ });
+
+ it('should verify two mirroring options are shown', () => {
+ const journal = fixture.debugElement.query(By.css('#journal')).nativeElement;
+ const snapshot = fixture.debugElement.query(By.css('#snapshot')).nativeElement;
+ expect(journal).not.toBeNull();
+ expect(snapshot).not.toBeNull();
+ });
+
+ it('should verify only snapshot is disabled for pools that are in pool mirror mode', () => {
+ component.poolMirrorMode = 'pool';
+ fixture.detectChanges();
+ const journal = fixture.debugElement.query(By.css('#journal')).nativeElement;
+ const snapshot = fixture.debugElement.query(By.css('#snapshot')).nativeElement;
+ expect(journal.disabled).toBe(false);
+ expect(snapshot.disabled).toBe(true);
+ });
+
+ it('should set and disable exclusive-lock only for the journal mode', () => {
+ component.poolMirrorMode = 'pool';
+ fixture.detectChanges();
+ const exclusiveLocks = fixture.debugElement.query(By.css('#exclusive-lock')).nativeElement;
+ expect(exclusiveLocks.checked).toBe(true);
+ expect(exclusiveLocks.disabled).toBe(true);
+ });
+ });
});
});
import { Pool } from '~/app/ceph/pool/pool';
import { PoolService } from '~/app/shared/api/pool.service';
+import { RbdMirroringService } from '~/app/shared/api/rbd-mirroring.service';
import { RbdService } from '~/app/shared/api/rbd.service';
import { ActionLabelsI18n } from '~/app/shared/constants/app.constants';
import { Icons } from '~/app/shared/enum/icons.enum';
defaultObjectSize = '4 MiB';
+ mirroringOptions = ['journal', 'snapshot'];
+ poolMirrorMode: string;
+ mirroring = false;
+ currentPoolName = '';
+
objectSizes: Array<string> = [
'4 KiB',
'8 KiB',
private taskWrapper: TaskWrapperService,
private dimlessBinaryPipe: DimlessBinaryPipe,
public actionLabels: ActionLabelsI18n,
- private router: Router
+ private router: Router,
+ private rbdMirroringService: RbdMirroringService
) {
super();
this.routerUrl = this.router.url;
allowDisable: true,
initDisabled: true
},
- journaling: {
- desc: $localize`Journaling (requires exclusive-lock)`,
- requires: 'exclusive-lock',
- allowEnable: true,
- allowDisable: true,
- initDisabled: true
- },
'fast-diff': {
desc: $localize`Fast diff (interlocked with object-map)`,
requires: 'object-map',
return acc;
}, {})
),
+ mirroring: new FormControl(false),
+ schedule: new FormControl('', {
+ validators: [Validators.pattern(/^([0-9]+)d|([0-9]+)h|([0-9]+)m$/)] // check schedule interval to be in format - 1d or 1h or 1m
+ }),
+ mirroringMode: new FormControl(this.mirroringOptions[0]),
stripingUnit: new FormControl(null),
stripingCount: new FormControl(null, {
updateOn: 'blur'
this.gatherNeededData().subscribe(this.handleExternalData.bind(this));
}
+ setExclusiveLock() {
+ if (this.mirroring && this.rbdForm.get('mirroringMode').value === 'journal') {
+ this.rbdForm.get('exclusive-lock').setValue(true);
+ this.rbdForm.get('exclusive-lock').disable();
+ } else {
+ this.rbdForm.get('exclusive-lock').enable();
+ if (this.poolMirrorMode === 'pool') {
+ this.rbdForm.get('mirroringMode').setValue(this.mirroringOptions[0]);
+ }
+ }
+ }
+
+ setMirrorMode() {
+ this.mirroring = !this.mirroring;
+ this.setExclusiveLock();
+ }
+
+ setPoolMirrorMode() {
+ this.currentPoolName =
+ this.mode === this.rbdFormMode.editing
+ ? this.response?.pool_name
+ : this.rbdForm.getValue('pool');
+ if (this.currentPoolName) {
+ this.rbdMirroringService.refresh();
+ this.rbdMirroringService.subscribeSummary((data) => {
+ const pool = data.content_data.pools.find((o: any) => o.name === this.currentPoolName);
+ this.poolMirrorMode = pool.mirror_mode;
+
+ if (pool.mirror_mode === 'disabled') {
+ this.mirroring = false;
+ this.rbdForm.get('mirroring').setValue(this.mirroring);
+ this.rbdForm.get('mirroring').disable();
+ } else if (this.mode !== this.rbdFormMode.editing) {
+ this.rbdForm.get('mirroring').enable();
+ this.mirroring = true;
+ this.rbdForm.get('mirroring').setValue(this.mirroring);
+ }
+ });
+ }
+ this.setExclusiveLock();
+ }
+
private prepareFormForAction() {
const url = this.routerUrl;
if (url.startsWith('/block/rbd/edit')) {
private handleExternalData(data: ExternalData) {
this.handlePoolData(data.pools);
+ this.setPoolMirrorMode();
if (data.defaultFeatures) {
// Fetched only during creation
}
if (this.mode === this.rbdFormMode.editing) {
this.rbdForm.get('name').setValue(response.name);
+ if (response?.mirror_mode === 'snapshot' || response.features_name.includes('journaling')) {
+ this.mirroring = true;
+ this.rbdForm.get('mirroring').setValue(this.mirroring);
+ this.rbdForm.get('mirroringMode').setValue(response?.mirror_mode);
+ this.rbdForm.get('schedule').setValue(response?.schedule_interval);
+ } else {
+ this.mirroring = false;
+ this.rbdForm.get('mirroring').setValue(this.mirroring);
+ }
+ this.setPoolMirrorMode();
}
this.rbdForm.get('pool').setValue(response.pool_name);
this.onPoolChange(response.pool_name);
request.pool_name = this.rbdForm.getValue('pool');
request.namespace = this.rbdForm.getValue('namespace');
request.name = this.rbdForm.getValue('name');
+ request.schedule_interval = this.rbdForm.getValue('schedule');
request.size = this.formatter.toBytes(this.rbdForm.getValue('size'));
+ if (this.poolMirrorMode === 'image') {
+ request.mirror_mode = this.rbdForm.getValue('mirroringMode');
+ }
this.addObjectSizeAndStripingToRequest(request);
request.configuration = this.getDirtyConfigurationValues();
return request;
}
});
+ if (this.mirroring && this.rbdForm.getValue('mirroringMode') === 'journal') {
+ request.features.push('journaling');
+ }
+
/* Striping */
request.stripe_unit = this.formatter.toBytes(this.rbdForm.getValue('stripingUnit'));
request.stripe_count = this.rbdForm.getValue('stripingCount');
task: new FinishedTask('rbd/create', {
pool_name: request.pool_name,
namespace: request.namespace,
- image_name: request.name
+ image_name: request.name,
+ schedule_interval: request.schedule_interval,
+ start_time: request.start_time
}),
call: this.rbdService.create(request)
});
editRequest() {
const request = new RbdFormEditRequestModel();
request.name = this.rbdForm.getValue('name');
+ request.schedule_interval = this.rbdForm.getValue('schedule');
+ request.name = this.rbdForm.getValue('name');
request.size = this.formatter.toBytes(this.rbdForm.getValue('size'));
_.forIn(this.features, (feature) => {
if (this.rbdForm.getValue(feature.key)) {
request.features.push(feature.key);
}
});
+ request.enable_mirror = this.rbdForm.getValue('mirroring');
+ if (this.poolMirrorMode === 'image') {
+ if (request.enable_mirror) {
+ request.mirror_mode = this.rbdForm.getValue('mirroringMode');
+ }
+ } else {
+ if (request.enable_mirror) {
+ request.features.push('journaling');
+ } else {
+ const index = request.features.indexOf('journaling', 0);
+ if (index > -1) {
+ request.features.splice(index, 1);
+ }
+ }
+ }
request.configuration = this.getDirtyConfigurationValues();
return request;
}
/* Deletion process */
source?: string;
+
+ enable_mirror?: boolean;
+ mirror_mode?: string;
+
+ schedule_interval: string;
+ start_time: string;
}
</cd-rbd-details>
</cd-table>
-<ng-template #usageNotAvailableTooltipTpl>
+<ng-template #scheduleStatus>
<div i18n
[innerHtml]="'Only available for RBD images with <strong>fast-diff</strong> enabled'"></div>
</ng-template>
<span *ngIf="!value">-</span>
</ng-template>
+<ng-template #mirroringTpl
+ let-value="value">
+ <span *ngIf="value.length === 3; else probb"
+ class="badge badge-info">{{ value[0] }}</span>
+ <span *ngIf="value.length === 3"
+ class="badge badge-info"
+ [ngbTooltip]="'Next scheduled snapshot on' + ' ' + (value[2] | cdDate)">{{ value[1] }}</span>
+ <ng-template #probb>
+ <span class="badge badge-info">{{ value }}</span>
+ </ng-template>
+</ng-template>
+
<ng-template #flattenTpl
let-value>
You are about to flatten
expect(tableActions).toEqual({
'create,update,delete': {
- actions: ['Create', 'Edit', 'Copy', 'Flatten', 'Delete', 'Move to Trash'],
+ actions: [
+ 'Create',
+ 'Edit',
+ 'Copy',
+ 'Flatten',
+ 'Delete',
+ 'Move to Trash',
+ 'Remove Scheduling'
+ ],
primary: { multiple: 'Create', executing: 'Edit', single: 'Edit', no: 'Create' }
},
'create,update': {
- actions: ['Create', 'Edit', 'Copy', 'Flatten'],
+ actions: ['Create', 'Edit', 'Copy', 'Flatten', 'Remove Scheduling'],
primary: { multiple: 'Create', executing: 'Edit', single: 'Edit', no: 'Create' }
},
'create,delete': {
primary: { multiple: 'Create', executing: 'Copy', single: 'Copy', no: 'Create' }
},
'update,delete': {
- actions: ['Edit', 'Flatten', 'Delete', 'Move to Trash'],
+ actions: ['Edit', 'Flatten', 'Delete', 'Move to Trash', 'Remove Scheduling'],
primary: { multiple: 'Edit', executing: 'Edit', single: 'Edit', no: 'Edit' }
},
update: {
- actions: ['Edit', 'Flatten'],
+ actions: ['Edit', 'Flatten', 'Remove Scheduling'],
primary: { multiple: 'Edit', executing: 'Edit', single: 'Edit', no: 'Edit' }
},
delete: {
import { NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
import _ from 'lodash';
+import { Observable, Subscriber } from 'rxjs';
import { RbdService } from '~/app/shared/api/rbd.service';
import { ListWithDetails } from '~/app/shared/classes/list-with-details.class';
import { TaskListService } from '~/app/shared/services/task-list.service';
import { TaskWrapperService } from '~/app/shared/services/task-wrapper.service';
import { URLBuilderService } from '~/app/shared/services/url-builder.service';
+import { RbdFormEditRequestModel } from '../rbd-form/rbd-form-edit-request.model';
import { RbdParentModel } from '../rbd-form/rbd-parent.model';
import { RbdTrashMoveModalComponent } from '../rbd-trash-move-modal/rbd-trash-move-modal.component';
import { RBDImageFormat, RbdModel } from './rbd-model';
parentTpl: TemplateRef<any>;
@ViewChild('nameTpl')
nameTpl: TemplateRef<any>;
+ @ViewChild('mirroringTpl', { static: true })
+ mirroringTpl: TemplateRef<any>;
@ViewChild('flattenTpl', { static: true })
flattenTpl: TemplateRef<any>;
@ViewChild('deleteTpl', { static: true })
metadata['dest_image_name']
)
};
+ remove_scheduling: boolean;
private createRbdFromTaskImageSpec(imageSpecStr: string): RbdModel {
const imageSpec = ImageSpec.fromString(imageSpecStr);
this.getInvalidNameDisable(selection) ||
selection.first().image_format === RBDImageFormat.V1
};
+ const removeSchedulingAction: CdTableAction = {
+ permission: 'update',
+ icon: Icons.edit,
+ click: () => this.removeSchedulingModal(),
+ name: this.actionLabels.REMOVE_SCHEDULING,
+ disable: (selection: CdTableSelection) =>
+ this.getRemovingStatusDesc(selection) ||
+ this.getInvalidNameDisable(selection) ||
+ selection.first().schedule_info === undefined
+ };
this.tableActions = [
addAction,
editAction,
copyAction,
flattenAction,
deleteAction,
- moveAction
+ moveAction,
+ removeSchedulingAction
];
}
prop: 'parent',
flexGrow: 2,
cellTemplate: this.parentTpl
+ },
+ {
+ name: $localize`Mirroring`,
+ prop: 'mirror_mode',
+ flexGrow: 3,
+ cellTemplate: this.mirroringTpl
}
];
this.tableStatus = new TableStatusViewCache();
}
+ images.forEach((image) => {
+ if (image.schedule_info !== undefined) {
+ let scheduling: any[] = [];
+ const scheduleStatus = 'scheduled';
+ let nextSnapshotDate = +new Date(image.schedule_info.schedule_time);
+ const offset = new Date().getTimezoneOffset();
+ nextSnapshotDate = nextSnapshotDate + Math.abs(offset) * 60000;
+ scheduling.push(image.mirror_mode, scheduleStatus, nextSnapshotDate);
+ image.mirror_mode = scheduling;
+ scheduling = [];
+ }
+ });
+
return images;
}
this.modalRef = this.modalService.show(ConfirmationModalComponent, initialState);
}
+ editRequest() {
+ const request = new RbdFormEditRequestModel();
+ request.remove_scheduling = !request.remove_scheduling;
+ return request;
+ }
+
+ removeSchedulingModal() {
+ const imageName = this.selection.first().name;
+
+ const imageSpec = new ImageSpec(
+ this.selection.first().pool_name,
+ this.selection.first().namespace,
+ this.selection.first().name
+ );
+
+ this.modalRef = this.modalService.show(CriticalConfirmationModalComponent, {
+ actionDescription: 'remove scheduling on',
+ itemDescription: $localize`image`,
+ itemNames: [`${imageName}`],
+ submitActionObservable: () =>
+ new Observable((observer: Subscriber<any>) => {
+ this.taskWrapper
+ .wrapTaskAroundCall({
+ task: new FinishedTask('rbd/edit', {
+ image_spec: imageSpec.toString()
+ }),
+ call: this.rbdService.update(imageSpec, this.editRequest())
+ })
+ .subscribe({
+ error: (resp) => observer.error(resp),
+ complete: () => {
+ this.modalRef.close();
+ }
+ });
+ })
+ });
+ }
+
hasSnapshots() {
const snapshots = this.selection.first()['snapshots'] || [];
return snapshots.length > 0;
placeholder="Snapshot name..."
id="snapshotName"
name="snapshotName"
+ [attr.disabled]="(mirroring === 'snapshot') ? true : null"
formControlName="snapshotName"
autofocus>
<span class="invalid-feedback"
*ngIf="snapshotForm.showError('snapshotName', formDir, 'required')"
- i18n>This field is required.</span>
+ i18n>This field is required.</span><br><br>
+ <span *ngIf="mirroring === 'snapshot'"
+ i18n>Snapshot mode is enabled on image <b>{{ imageName }}</b>: snapshot names are auto generated</span>
</div>
</div>
</div>
namespace: string;
imageName: string;
snapName: string;
+ mirroring: string;
snapshotForm: CdFormGroup;
setSnapName(snapName: string) {
this.snapName = snapName;
- this.snapshotForm.get('snapshotName').setValue(snapName);
+ if (this.mirroring !== 'snapshot') {
+ this.snapshotForm.get('snapshotName').setValue(snapName);
+ } else {
+ this.snapshotForm.get('snapshotName').clearValidators();
+ }
}
/**
this.rename = {
permission: 'update',
icon: Icons.edit,
- name: actionLabels.RENAME
+ name: actionLabels.RENAME,
+ disable: (selection: CdTableSelection) => this.disableForMirrorSnapshot(selection)
};
this.protect = {
permission: 'update',
icon: Icons.lock,
visible: (selection: CdTableSelection) =>
selection.hasSingleSelection && !selection.first().is_protected,
- name: actionLabels.PROTECT
+ name: actionLabels.PROTECT,
+ disable: (selection: CdTableSelection) => this.disableForMirrorSnapshot(selection)
};
this.unprotect = {
permission: 'update',
icon: Icons.unlock,
visible: (selection: CdTableSelection) =>
selection.hasSingleSelection && selection.first().is_protected,
- name: actionLabels.UNPROTECT
+ name: actionLabels.UNPROTECT,
+ disable: (selection: CdTableSelection) => this.disableForMirrorSnapshot(selection)
};
this.clone = {
permission: 'create',
canBePrimary: (selection: CdTableSelection) => selection.hasSingleSelection,
disable: (selection: CdTableSelection) =>
- this.getCloneDisableDesc(selection, this.featuresName),
+ this.getCloneDisableDesc(selection, this.featuresName) ||
+ this.disableForMirrorSnapshot(selection),
icon: Icons.clone,
name: actionLabels.CLONE
};
permission: 'create',
canBePrimary: (selection: CdTableSelection) => selection.hasSingleSelection,
disable: (selection: CdTableSelection) =>
- !selection.hasSingleSelection || selection.first().cdExecuting,
+ !selection.hasSingleSelection ||
+ selection.first().cdExecuting ||
+ this.disableForMirrorSnapshot(selection),
icon: Icons.copy,
name: actionLabels.COPY
};
this.rollback = {
permission: 'update',
icon: Icons.undo,
- name: actionLabels.ROLLBACK
+ name: actionLabels.ROLLBACK,
+ disable: (selection: CdTableSelection) => this.disableForMirrorSnapshot(selection)
};
this.deleteSnap = {
permission: 'delete',
icon: Icons.destroy,
disable: (selection: CdTableSelection) => {
const first = selection.first();
- return !selection.hasSingleSelection || first.cdExecuting || first.is_protected;
+ return (
+ !selection.hasSingleSelection ||
+ first.cdExecuting ||
+ first.is_protected ||
+ this.disableForMirrorSnapshot(selection)
+ );
},
name: actionLabels.DELETE
};
return true;
}
+
+ disableForMirrorSnapshot(selection: CdTableSelection) {
+ return (
+ selection.hasSingleSelection &&
+ selection.first().mirror_mode === 'snapshot' &&
+ selection.first().name.includes('.mirror.')
+ );
+ }
}
@Input()
namespace: string;
@Input()
+ mirroring: string;
+ @Input()
rbdName: string;
@ViewChild('nameTpl')
nameTpl: TemplateRef<any>;
}
private openSnapshotModal(taskName: string, snapName: string = null) {
- this.modalRef = this.modalService.show(RbdSnapshotFormModalComponent);
+ const modalVariables = {
+ mirroring: this.mirroring
+ };
+ this.modalRef = this.modalService.show(RbdSnapshotFormModalComponent, modalVariables);
this.modalRef.componentInstance.poolName = this.poolName;
this.modalRef.componentInstance.imageName = this.rbdName;
this.modalRef.componentInstance.namespace = this.namespace;
FLAGS: string;
ENTER_MAINTENANCE: string;
EXIT_MAINTENANCE: string;
+ REMOVE_SCHEDULING: string;
START_DRAIN: string;
STOP_DRAIN: string;
START: string;
this.FLAGS = $localize`Flags`;
this.ENTER_MAINTENANCE = $localize`Enter Maintenance`;
this.EXIT_MAINTENANCE = $localize`Exit Maintenance`;
+
this.START_DRAIN = $localize`Start Drain`;
this.STOP_DRAIN = $localize`Stop Drain`;
this.STOP = $localize`Stop`;
this.REDEPLOY = $localize`Redeploy`;
this.RESTART = $localize`Restart`;
+
+ this.REMOVE_SCHEDULING = $localize`Remove Scheduling`;
}
}
padding-top: 7px;
}
+.custom-radio {
+ padding-top: 5px;
+}
+
.cd-col-form {
@extend .col-12;
@extend .col-lg-8;
type: string
features:
type: string
+ mirror_mode:
+ type: string
name:
type: string
namespace:
type: integer
pool_name:
type: string
+ schedule_interval:
+ default: ''
+ type: string
size:
type: integer
stripe_count:
type: string
primary:
type: string
+ remove_scheduling:
+ default: false
+ type: boolean
resync:
default: false
type: boolean
type: string
size:
type: integer
- start_time:
- default: ''
- type: string
type: object
responses:
'200':
# -*- coding: utf-8 -*-
# pylint: disable=unused-argument
import errno
+import json
+from enum import IntEnum
import cherrypy
import rbd
from .. import mgr
+from ..exceptions import DashboardException
from ..tools import ViewCache
from .ceph_service import CephService
}
+class MIRROR_IMAGE_MODE(IntEnum):
+ journal = rbd.RBD_MIRROR_IMAGE_MODE_JOURNAL
+ snapshot = rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT
+
+
+def _rbd_support_remote(method_name: str, *args, **kwargs):
+ try:
+ return mgr.remote('rbd_support', method_name, *args, **kwargs)
+ except ImportError as ie:
+ raise DashboardException(f'rbd_support module not found {ie}')
+ except RuntimeError as ie:
+ raise DashboardException(f'rbd_support.{method_name} error: {ie}')
+
+
def format_bitmask(features):
"""
Formats the bitmask:
return total_used_size, snap_map
@classmethod
- def _rbd_image(cls, ioctx, pool_name, namespace, image_name):
+ def _rbd_image(cls, ioctx, pool_name, namespace, image_name): # pylint: disable=R0912
with rbd.Image(ioctx, image_name) as img:
-
stat = img.stat()
+ mirror_mode = img.mirror_image_get_mode()
+ if mirror_mode == rbd.RBD_MIRROR_IMAGE_MODE_JOURNAL:
+ stat['mirror_mode'] = 'journal'
+ elif mirror_mode == rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT:
+ stat['mirror_mode'] = 'snapshot'
+ schedule_status = json.loads(_rbd_support_remote(
+ 'mirror_snapshot_schedule_status')[1])
+ for scheduled_image in schedule_status['scheduled_images']:
+ if scheduled_image['image'] == get_image_spec(pool_name, namespace, image_name):
+ stat['schedule_info'] = scheduled_image
+ else:
+ stat['mirror_mode'] = 'unknown'
+
stat['name'] = image_name
if img.old_format():
stat['unique_id'] = get_image_spec(pool_name, namespace, stat['block_name_prefix'])
# snapshots
stat['snapshots'] = []
for snap in img.list_snaps():
+ try:
+ snap['mirror_mode'] = MIRROR_IMAGE_MODE(img.mirror_image_get_mode()).name
+ except ValueError as ex:
+ raise DashboardException(f'Unknown RBD Mirror mode: {ex}')
+
snap['timestamp'] = "{}Z".format(
img.get_snap_timestamp(snap['id']).isoformat())
- snap['is_protected'] = img.is_protected_snap(snap['name'])
+
+ snap['is_protected'] = None
+ if mirror_mode != rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT:
+ snap['is_protected'] = img.is_protected_snap(snap['name'])
snap['used_bytes'] = None
snap['children'] = []
- img.set_snap(snap['name'])
- for child_pool_name, child_image_name in img.list_children():
- snap['children'].append({
- 'pool_name': child_pool_name,
- 'image_name': child_image_name
- })
+
+ if mirror_mode != rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT:
+ img.set_snap(snap['name'])
+ for child_pool_name, child_image_name in img.list_children():
+ snap['children'].append({
+ 'pool_name': child_pool_name,
+ 'image_name': child_image_name
+ })
stat['snapshots'].append(snap)
# disk usage
img_flags = img.flags()
if 'fast-diff' in stat['features_name'] and \
- not rbd.RBD_FLAG_FAST_DIFF_INVALID & img_flags:
+ not rbd.RBD_FLAG_FAST_DIFF_INVALID & img_flags and \
+ mirror_mode != rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT:
snaps = [(s['id'], s['size'], s['name'])
for s in stat['snapshots']]
snaps.sort(key=lambda s: s[0])
class RbdMirroringService:
@classmethod
- def enable_image(cls, image_name: str, pool_name: str, namespace: str, mode: str):
+ def enable_image(cls, image_name: str, pool_name: str, namespace: str, mode: MIRROR_IMAGE_MODE):
rbd_image_call(pool_name, namespace, image_name,
lambda ioctx, image: image.mirror_image_enable(mode))
lambda ioctx, image: image.mirror_image_resync())
@classmethod
- def snapshot_schedule(cls, image_spec: str, interval: str, start_time: str = ''):
- mgr.remote('rbd_support', 'mirror_snapshot_schedule_add', image_spec,
- str(RBDSchedulerInterval(interval)), start_time)
+ def snapshot_schedule_add(cls, image_spec: str, interval: str):
+ _rbd_support_remote('mirror_snapshot_schedule_add', image_spec,
+ str(RBDSchedulerInterval(interval)))
+
+ @classmethod
+ def snapshot_schedule_remove(cls, image_spec: str):
+ _rbd_support_remote('mirror_snapshot_schedule_remove', image_spec)
projects / ceph.git / commitdiff