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             height: 300,
 341             cbind: {
 342                 nodename: '{nodename}',
 343             },
 344             viewModel: {
 345                 data: {
 346                     replicas: undefined,
 347                     minreplicas: undefined,
 348                 },
 349             },
 350             listeners: {
 351                 activate: function() {
 352                     this.up('pveCephInstallWizard').down('#submit').setText(gettext('Next'));
 353                 },
 354                 afterrender: function() {
 355                     if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
 356                         this.mask("Configuration already initialized", ['pve-static-mask']);
 357                     } else {
 358                         this.unmask();
 359                     }
 360                 },
 361                 deactivate: function() {
 362                     this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
 363                 },
 364             },
 365             column1: [
 366                 {
 367                     xtype: 'displayfield',
 368                     value: gettext('Ceph cluster configuration') + ':',
 369                 },
 370                 {
 371                     xtype: 'proxmoxNetworkSelector',
 372                     name: 'network',
 373                     value: '',
 374                     fieldLabel: 'Public Network IP/CIDR',
 375                     bind: {
 376                         allowBlank: '{configuration}',
 377                     },
 378                     cbind: {
 379                         nodename: '{nodename}',
 380                     },
 381                 },
 382                 {
 383                     xtype: 'proxmoxNetworkSelector',
 384                     name: 'cluster-network',
 385                     fieldLabel: 'Cluster Network IP/CIDR',
 386                     allowBlank: true,
 387                     autoSelect: false,
 388                     emptyText: gettext('Same as Public Network'),
 389                     cbind: {
 390                         nodename: '{nodename}',
 391                     },
 392                 },
 393                 // FIXME: add hint about cluster network and/or reference user to docs??
 394             ],
 395             column2: [
 396                 {
 397                     xtype: 'displayfield',
 398                     value: gettext('First Ceph monitor') + ':',
 399                 },
 400                 {
 401                     xtype: 'pveNodeSelector',
 402                     fieldLabel: gettext('Monitor node'),
 403                     name: 'mon-node',
 404                     selectCurNode: true,
 405                     allowBlank: false,
 406                 },
 407                 {
 408                     xtype: 'displayfield',
 409                     value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
 410                     userCls: 'pmx-hint',
 411                 },
 412             ],
 413             advancedColumn1: [
 414                 {
 415                     xtype: 'numberfield',
 416                     name: 'size',
 417                     fieldLabel: 'Number of replicas',
 418                     bind: {
 419                         value: '{replicas}',
 420                     },
 421                     maxValue: 7,
 422                     minValue: 2,
 423                     emptyText: '3',
 424                 },
 425                 {
 426                     xtype: 'numberfield',
 427                     name: 'min_size',
 428                     fieldLabel: 'Minimum replicas',
 429                     bind: {
 430                         maxValue: '{replicas}',
 431                         value: '{minreplicas}',
 432                     },
 433                     minValue: 2,
 434                     maxValue: 3,
 435                     setMaxValue: function(value) {
 436                         this.maxValue = Ext.Number.from(value, 2);
 437                         // allow enough to avoid split brains with max 'size', but more makes simply no sense
 438                         if (this.maxValue > 4) {
 439                             this.maxValue = 4;
 440                         }
 441                         this.toggleSpinners();
 442                         this.validate();
 443                     },
 444                     emptyText: '2',
 445                 },
 446             ],
 447             onGetValues: function(values) {
 448                 ['cluster-network', 'size', 'min_size'].forEach(function(field) {
 449                     if (!values[field]) {
 450                         delete values[field];
 451                     }
 452                 });
 453                 return values;
 454             },
 455             onSubmit: function() {
 456                 var me = this;
 457                 if (!this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
 458                     var wizard = me.up('window');
 459                     var kv = wizard.getValues();
 460                     delete kv.delete;
 461                     var monNode = kv['mon-node'];
 462                     delete kv['mon-node'];
 463                     var nodename = me.nodename;
 464                     delete kv.nodename;
 465                     Proxmox.Utils.API2Request({
 466                         url: `/nodes/${nodename}/ceph/init`,
 467                         waitMsgTarget: wizard,
 468                         method: 'POST',
 469                         params: kv,
 470                         success: function() {
 471                             Proxmox.Utils.API2Request({
 472                                 url: `/nodes/${monNode}/ceph/mon/${monNode}`,
 473                                 waitMsgTarget: wizard,
 474                                 method: 'POST',
 475                                 success: function() {
 476                                     me.up('pveCephInstallWizard').navigateNext();
 477                                 },
 478                                 failure: function(response, opts) {
 479                                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 480                                 },
 481                             });
 482                         },
 483                         failure: function(response, opts) {
 484                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 485                         },
 486                     });
 487                 } else {
 488                     me.up('pveCephInstallWizard').navigateNext();
 489                 }
 490             },
 491         },
 492         {
 493             title: gettext('Success'),
 494             xtype: 'panel',
 495             border: false,
 496             bodyBorder: false,
 497             onlineHelp: 'pve_ceph_install',
 498             html: '<h3>Installation successful!</h3>'+
 499             '<p>The basic installation and configuration is complete. Depending on your setup, some of the following steps are required to start using Ceph:</p>'+
 500                 '<ol><li>Install Ceph on other nodes</li>'+
 501                 '<li>Create additional Ceph Monitors</li>'+
 502                 '<li>Create Ceph OSDs</li>'+
 503                 '<li>Create Ceph Pools</li></ol>'+
 504             '<p>To learn more, click on the help button below.</p>',
 505             listeners: {
 506                 activate: function() {
 507                     // notify owning container that it should display a help button
 508                     if (this.onlineHelp) {
 509                         Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
 510                     }
 511
 512                     var tp = this.up('#wizcontent');
 513                     var idx = tp.items.indexOf(this)-1;
 514                     for (;idx >= 0; idx--) {
 515                         var nc = tp.items.getAt(idx);
 516                         if (nc) {
 517                             nc.disable();
 518                         }
 519                     }
 520                 },
 521                 deactivate: function() {
 522                     if (this.onlineHelp) {
 523                         Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
 524                     }
 525                 },
 526             },
 527             onSubmit: function() {
 528                 var wizard = this.up('pveCephInstallWizard');
 529                 wizard.close();
 530             },
 531         },
 532     ],
 533 });