www/manager6/ceph/CephInstallWizard.js

   1 Ext.define('PVE.ceph.CephInstallWizardInfo', {
   2     extend: 'Ext.panel.Panel',
   3     xtype: 'pveCephInstallWizardInfo',
   4
   5     html: `<h3>Ceph?</h3>
   6     <blockquote cite="https://ceph.com/"><p>"<b>Ceph</b> is a unified,
   7     distributed storage system, designed for excellent performance, reliability,
   8     and scalability."</p></blockquote>
   9     <p>
  10     <b>Ceph</b> is currently <b>not installed</b> on this node. This wizard
  11     will guide you through the installation. Click on the next button below
  12     to begin. After the initial installation, the wizard will offer to create
  13     an initial configuration. This configuration step is only
  14     needed once per cluster and will be skipped if a config is already present.
  15     </p>
  16     <p>
  17     Before starting the installation, please take a look at our documentation,
  18     by clicking the help button below. If you want to gain deeper knowledge about
  19     Ceph, visit <a target="_blank" href="https://docs.ceph.com/en/latest/">ceph.com</a>.
  20     </p>`,
  21 });
  22
  23 Ext.define('PVE.ceph.CephVersionSelector', {
  24     extend: 'Ext.form.field.ComboBox',
  25     xtype: 'pveCephVersionSelector',
  26
  27     fieldLabel: gettext('Ceph version to install'),
  28
  29     displayField: 'display',
  30     valueField: 'release',
  31
  32     queryMode: 'local',
  33     editable: false,
  34     forceSelection: true,
  35
  36     store: {
  37         fields: [
  38             'release',
  39             'version',
  40             {
  41                 name: 'display',
  42                 calculate: d => `${d.release} (${d.version})`,
  43             },
  44         ],
  45         proxy: {
  46             type: 'memory',
  47             reader: {
  48                 type: 'json',
  49             },
  50         },
  51         data: [
  52             { release: "octopus", version: "15.2" },
  53             { release: "pacific", version: "16.2" },
  54         ],
  55     },
  56 });
  57
  58 Ext.define('PVE.ceph.CephHighestVersionDisplay', {
  59     extend: 'Ext.form.field.Display',
  60     xtype: 'pveCephHighestVersionDisplay',
  61
  62     fieldLabel: gettext('Ceph in the cluster'),
  63
  64     value: 'unknown',
  65
  66     // called on success with (release, versionTxt, versionParts)
  67     gotNewestVersion: Ext.emptyFn,
  68
  69     initComponent: function() {
  70         let me = this;
  71
  72         me.callParent(arguments);
  73
  74         Proxmox.Utils.API2Request({
  75             method: 'GET',
  76             url: '/cluster/ceph/metadata',
  77             params: {
  78                 scope: 'versions',
  79             },
  80             waitMsgTarget: me,
  81             success: (response) => {
  82                 let res = response.result;
  83                 if (!res || !res.data || !res.data.node) {
  84                     me.setValue(
  85                         gettext('Could not detect a ceph installation in the cluster'),
  86                     );
  87                     return;
  88                 }
  89                 let nodes = res.data.node;
  90                 if (me.nodename) {
  91                     // can happen on ceph purge, we do not yet cleanup old version data
  92                     delete nodes[me.nodename];
  93                 }
  94
  95                 let maxversion = [];
  96                 let maxversiontext = "";
  97                 for (const [_nodename, data] of Object.entries(nodes)) {
  98                     let version = data.version.parts;
  99                     if (PVE.Utils.compare_ceph_versions(version, maxversion) > 0) {
 100                         maxversion = version;
 101                         maxversiontext = data.version.str;
 102                     }
 103                 }
 104                 // FIXME: get from version selector store
 105                 const major2release = {
 106                     13: 'luminous',
 107                     14: 'nautilus',
 108                     15: 'octopus',
 109                     16: 'pacific',
 110                 };
 111                 let release = major2release[maxversion[0]] || 'unknown';
 112                 let newestVersionTxt = `${Ext.String.capitalize(release)} (${maxversiontext})`;
 113
 114                 if (release === 'unknown') {
 115                     me.setValue(
 116                         gettext('Could not detect a ceph installation in the cluster'),
 117                     );
 118                 } else {
 119                     me.setValue(Ext.String.format(
 120                         gettext('Newest ceph version in cluster is {0}'),
 121                         newestVersionTxt,
 122                     ));
 123                 }
 124                 me.gotNewestVersion(release, maxversiontext, maxversion);
 125             },
 126             failure: function(response, opts) {
 127                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 128             },
 129         });
 130     },
 131 });
 132
 133 Ext.define('PVE.ceph.CephInstallWizard', {
 134     extend: 'PVE.window.Wizard',
 135     alias: 'widget.pveCephInstallWizard',
 136     mixins: ['Proxmox.Mixin.CBind'],
 137
 138     resizable: false,
 139     nodename: undefined,
 140
 141     viewModel: {
 142         data: {
 143             nodename: '',
 144             cephRelease: 'pacific',
 145             configuration: true,
 146             isInstalled: false,
 147         },
 148     },
 149     cbindData: {
 150         nodename: undefined,
 151     },
 152
 153     title: gettext('Setup'),
 154     navigateNext: function() {
 155         var tp = this.down('#wizcontent');
 156         var atab = tp.getActiveTab();
 157
 158         var next = tp.items.indexOf(atab) + 1;
 159         var ntab = tp.items.getAt(next);
 160         if (ntab) {
 161             ntab.enable();
 162             tp.setActiveTab(ntab);
 163         }
 164     },
 165     setInitialTab: function(index) {
 166         var tp = this.down('#wizcontent');
 167         var initialTab = tp.items.getAt(index);
 168         initialTab.enable();
 169         tp.setActiveTab(initialTab);
 170     },
 171     onShow: function() {
 172             this.callParent(arguments);
 173             var isInstalled = this.getViewModel().get('isInstalled');
 174             if (isInstalled) {
 175                 this.getViewModel().set('configuration', false);
 176                 this.setInitialTab(2);
 177             }
 178     },
 179     items: [
 180         {
 181             xtype: 'panel',
 182             title: gettext('Info'),
 183             viewModel: {}, // needed to inherit parent viewModel data
 184             border: false,
 185             bodyBorder: false,
 186             onlineHelp: 'chapter_pveceph',
 187             layout: {
 188                 type: 'vbox',
 189                 align: 'stretch',
 190             },
 191             defaults: {
 192                 border: false,
 193                 bodyBorder: false,
 194             },
 195             items: [
 196                 {
 197                     xtype: 'pveCephInstallWizardInfo',
 198                 },
 199                 {
 200                     flex: 1,
 201                 },
 202                 {
 203                     xtype: 'pveCephHighestVersionDisplay',
 204                     labelWidth: 180,
 205                     cbind: {
 206                         nodename: '{nodename}',
 207                     },
 208                     gotNewestVersion: function(release, maxversiontext, maxversion) {
 209                         if (release === 'unknown') {
 210                             return;
 211                         }
 212                         let wizard = this.up('pveCephInstallWizard');
 213                         wizard.getViewModel().set('cephRelease', release);
 214                     },
 215                 },
 216                 {
 217                     xtype: 'pveCephVersionSelector',
 218                     labelWidth: 180,
 219                     submitValue: false,
 220                     bind: {
 221                         value: '{cephRelease}',
 222                     },
 223                     listeners: {
 224                         change: function(field, release) {
 225                             let wizard = this.up('pveCephInstallWizard');
 226                             wizard.down('#next').setText(
 227                                 Ext.String.format(gettext('Start {0} installation'), release),
 228                             );
 229                         },
 230                     },
 231                 },
 232             ],
 233             listeners: {
 234                 activate: function() {
 235                     // notify owning container that it should display a help button
 236                     if (this.onlineHelp) {
 237                         Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
 238                     }
 239                     let wizard = this.up('pveCephInstallWizard');
 240                     let release = wizard.getViewModel().get('cephRelease');
 241                     wizard.down('#back').hide(true);
 242                     wizard.down('#next').setText(
 243                         Ext.String.format(gettext('Start {0} installation'), release),
 244                     );
 245                 },
 246                 deactivate: function() {
 247                     if (this.onlineHelp) {
 248                         Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
 249                     }
 250                     this.up('pveCephInstallWizard').down('#next').setText(gettext('Next'));
 251                 },
 252             },
 253         },
 254         {
 255             title: gettext('Installation'),
 256             xtype: 'panel',
 257             layout: 'fit',
 258             cbind: {
 259                 nodename: '{nodename}',
 260             },
 261             viewModel: {}, // needed to inherit parent viewModel data
 262             listeners: {
 263                 afterrender: function() {
 264                     var me = this;
 265                     if (this.getViewModel().get('isInstalled')) {
 266                         this.mask("Ceph is already installed, click next to create your configuration.", ['pve-static-mask']);
 267                     } else {
 268                         me.down('pveNoVncConsole').fireEvent('activate');
 269                     }
 270                 },
 271                 activate: function() {
 272                     let me = this;
 273                     const nodename = me.nodename;
 274                     me.updateStore = Ext.create('Proxmox.data.UpdateStore', {
 275                         storeid: 'ceph-status-' + nodename,
 276                         interval: 1000,
 277                         proxy: {
 278                             type: 'proxmox',
 279                             url: '/api2/json/nodes/' + nodename + '/ceph/status',
 280                         },
 281                         listeners: {
 282                             load: function(rec, response, success, operation) {
 283                                 if (success) {
 284                                     me.updateStore.stopUpdate();
 285                                     me.down('textfield').setValue('success');
 286                                 } else if (operation.error.statusText.match("not initialized", "i")) {
 287                                     me.updateStore.stopUpdate();
 288                                     me.up('pveCephInstallWizard').getViewModel().set('configuration', false);
 289                                     me.down('textfield').setValue('success');
 290                                 } else if (operation.error.statusText.match("rados_connect failed", "i")) {
 291                                     me.updateStore.stopUpdate();
 292                                     me.up('pveCephInstallWizard').getViewModel().set('configuration', true);
 293                                     me.down('textfield').setValue('success');
 294                                 } else if (!operation.error.statusText.match("not installed", "i")) {
 295                                     Proxmox.Utils.setErrorMask(me, operation.error.statusText);
 296                                 }
 297                             },
 298                         },
 299                     });
 300                     me.updateStore.startUpdate();
 301                 },
 302                 destroy: function() {
 303                     var me = this;
 304                     if (me.updateStore) {
 305                         me.updateStore.stopUpdate();
 306                     }
 307                 },
 308             },
 309             items: [
 310                 {
 311                     xtype: 'pveNoVncConsole',
 312                     itemId: 'jsconsole',
 313                     consoleType: 'cmd',
 314                     xtermjs: true,
 315                     cbind: {
 316                         nodename: '{nodename}',
 317                     },
 318                     beforeLoad: function() {
 319                         let me = this;
 320                         let wizard = me.up('pveCephInstallWizard');
 321                         let release = wizard.getViewModel().get('cephRelease');
 322                         me.cmdOpts = `--version\0${release}`;
 323                     },
 324                     cmd: 'ceph_install',
 325                 },
 326                 {
 327                     xtype: 'textfield',
 328                     name: 'installSuccess',
 329                     value: '',
 330                     allowBlank: false,
 331                     submitValue: false,
 332                     hidden: true,
 333                 },
 334             ],
 335         },
 336         {
 337             xtype: 'inputpanel',
 338             title: gettext('Configuration'),
 339             onlineHelp: 'chapter_pveceph',
 340             cbind: {
 341                 nodename: '{nodename}',
 342             },
 343             viewModel: {
 344                 data: {
 345                     replicas: undefined,
 346                     minreplicas: undefined,
 347                 },
 348             },
 349             listeners: {
 350                 activate: function() {
 351                     this.up('pveCephInstallWizard').down('#submit').setText(gettext('Next'));
 352                 },
 353                 beforeshow: function() {
 354                     if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
 355                         this.mask("Configuration already initialized", ['pve-static-mask']);
 356                     } else {
 357                         this.unmask();
 358                     }
 359                 },
 360                 deactivate: function() {
 361                     this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
 362                 },
 363             },
 364             column1: [
 365                 {
 366                     xtype: 'displayfield',
 367                     value: gettext('Ceph cluster configuration') + ':',
 368                 },
 369                 {
 370                     xtype: 'proxmoxNetworkSelector',
 371                     name: 'network',
 372                     value: '',
 373                     fieldLabel: 'Public Network IP/CIDR',
 374                     bind: {
 375                         allowBlank: '{configuration}',
 376                     },
 377                     cbind: {
 378                         nodename: '{nodename}',
 379                     },
 380                 },
 381                 {
 382                     xtype: 'proxmoxNetworkSelector',
 383                     name: 'cluster-network',
 384                     fieldLabel: 'Cluster Network IP/CIDR',
 385                     allowBlank: true,
 386                     autoSelect: false,
 387                     emptyText: gettext('Same as Public Network'),
 388                     cbind: {
 389                         nodename: '{nodename}',
 390                     },
 391                 },
 392                 // FIXME: add hint about cluster network and/or reference user to docs??
 393             ],
 394             column2: [
 395                 {
 396                     xtype: 'displayfield',
 397                     value: gettext('First Ceph monitor') + ':',
 398                 },
 399                 {
 400                     xtype: 'pveNodeSelector',
 401                     fieldLabel: gettext('Monitor node'),
 402                     name: 'mon-node',
 403                     selectCurNode: true,
 404                     allowBlank: false,
 405                 },
 406                 {
 407                     xtype: 'displayfield',
 408                     value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
 409                     userCls: 'pmx-hint',
 410                 },
 411             ],
 412             advancedColumn1: [
 413                 {
 414                     xtype: 'numberfield',
 415                     name: 'size',
 416                     fieldLabel: 'Number of replicas',
 417                     bind: {
 418                         value: '{replicas}',
 419                     },
 420                     maxValue: 7,
 421                     minValue: 2,
 422                     emptyText: '3',
 423                 },
 424                 {
 425                     xtype: 'numberfield',
 426                     name: 'min_size',
 427                     fieldLabel: 'Minimum replicas',
 428                     bind: {
 429                         maxValue: '{replicas}',
 430                         value: '{minreplicas}',
 431                     },
 432                     minValue: 2,
 433                     maxValue: 3,
 434                     setMaxValue: function(value) {
 435                         this.maxValue = Ext.Number.from(value, 2);
 436                         // allow enough to avoid split brains with max 'size', but more makes simply no sense
 437                         if (this.maxValue > 4) {
 438                             this.maxValue = 4;
 439                         }
 440                         this.toggleSpinners();
 441                         this.validate();
 442                     },
 443                     emptyText: '2',
 444                 },
 445             ],
 446             onGetValues: function(values) {
 447                 ['cluster-network', 'size', 'min_size'].forEach(function(field) {
 448                     if (!values[field]) {
 449                         delete values[field];
 450                     }
 451                 });
 452                 return values;
 453             },
 454             onSubmit: function() {
 455                 var me = this;
 456                 if (!this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
 457                     var wizard = me.up('window');
 458                     var kv = wizard.getValues();
 459                     delete kv.delete;
 460                     var monNode = kv['mon-node'];
 461                     delete kv['mon-node'];
 462                     var nodename = me.nodename;
 463                     delete kv.nodename;
 464                     Proxmox.Utils.API2Request({
 465                         url: `/nodes/${nodename}/ceph/init`,
 466                         waitMsgTarget: wizard,
 467                         method: 'POST',
 468                         params: kv,
 469                         success: function() {
 470                             Proxmox.Utils.API2Request({
 471                                 url: `/nodes/${monNode}/ceph/mon/${monNode}`,
 472                                 waitMsgTarget: wizard,
 473                                 method: 'POST',
 474                                 success: function() {
 475                                     me.up('pveCephInstallWizard').navigateNext();
 476                                 },
 477                                 failure: function(response, opts) {
 478                                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 479                                 },
 480                             });
 481                         },
 482                         failure: function(response, opts) {
 483                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 484                         },
 485                     });
 486                 } else {
 487                     me.up('pveCephInstallWizard').navigateNext();
 488                 }
 489             },
 490         },
 491         {
 492             title: gettext('Success'),
 493             xtype: 'panel',
 494             border: false,
 495             bodyBorder: false,
 496             onlineHelp: 'pve_ceph_install',
 497             html: '<h3>Installation successful!</h3>'+
 498             '<p>The basic installation and configuration is complete. Depending on your setup, some of the following steps are required to start using Ceph:</p>'+
 499                 '<ol><li>Install Ceph on other nodes</li>'+
 500                 '<li>Create additional Ceph Monitors</li>'+
 501                 '<li>Create Ceph OSDs</li>'+
 502                 '<li>Create Ceph Pools</li></ol>'+
 503             '<p>To learn more, click on the help button below.</p>',
 504             listeners: {
 505                 activate: function() {
 506                     // notify owning container that it should display a help button
 507                     if (this.onlineHelp) {
 508                         Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
 509                     }
 510
 511                     var tp = this.up('#wizcontent');
 512                     var idx = tp.items.indexOf(this)-1;
 513                     for (;idx >= 0; idx--) {
 514                         var nc = tp.items.getAt(idx);
 515                         if (nc) {
 516                             nc.disable();
 517                         }
 518                     }
 519                 },
 520                 deactivate: function() {
 521                     if (this.onlineHelp) {
 522                         Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
 523                     }
 524                 },
 525             },
 526             onSubmit: function() {
 527                 var wizard = this.up('pveCephInstallWizard');
 528                 wizard.close();
 529             },
 530         },
 531     ],
 532 });