www/manager6/Utils.js

   1 Ext.ns('PVE');
   2
   3 // avoid errors related to Accessible Rich Internet Applications
   4 // (access for people with disabilities)
   5 // TODO reenable after all components are upgraded
   6 Ext.enableAria = false;
   7 Ext.enableAriaButtons = false;
   8 Ext.enableAriaPanels = false;
   9
  10 console.log("Starting Proxmox VE Manager");
  11
  12 Ext.Ajax.defaultHeaders = {
  13     'Accept': 'application/json',
  14 };
  15
  16 Ext.define('PVE.Utils', {
  17  utilities: {
  18
  19     // this singleton contains miscellaneous utilities
  20
  21     toolkit: undefined, // (extjs|touch), set inside Toolkit.js
  22
  23     bus_match: /^(ide|sata|virtio|scsi)\d+$/,
  24
  25     log_severity_hash: {
  26         0: "panic",
  27         1: "alert",
  28         2: "critical",
  29         3: "error",
  30         4: "warning",
  31         5: "notice",
  32         6: "info",
  33         7: "debug",
  34     },
  35
  36     support_level_hash: {
  37         'c': gettext('Community'),
  38         'b': gettext('Basic'),
  39         's': gettext('Standard'),
  40         'p': gettext('Premium'),
  41     },
  42
  43     noSubKeyHtml: 'You do not have a valid subscription for this server. Please visit '
  44       +'<a target="_blank" href="https://www.proxmox.com/products/proxmox-ve/subscription-service-plans">'
  45       +'www.proxmox.com</a> to get a list of available options.',
  46
  47     kvm_ostypes: {
  48         'Linux': [
  49             { desc: '5.x - 2.6 Kernel', val: 'l26' },
  50             { desc: '2.4 Kernel', val: 'l24' },
  51         ],
  52         'Microsoft Windows': [
  53             { desc: '10/2016/2019', val: 'win10' },
  54             { desc: '8.x/2012/2012r2', val: 'win8' },
  55             { desc: '7/2008r2', val: 'win7' },
  56             { desc: 'Vista/2008', val: 'w2k8' },
  57             { desc: 'XP/2003', val: 'wxp' },
  58             { desc: '2000', val: 'w2k' },
  59         ],
  60         'Solaris Kernel': [
  61             { desc: '-', val: 'solaris' },
  62         ],
  63         'Other': [
  64             { desc: '-', val: 'other' },
  65         ],
  66     },
  67
  68     is_windows: function(ostype) {
  69         for (let entry of PVE.Utils.kvm_ostypes['Microsoft Windows']) {
  70             if (entry.val === ostype) {
  71                 return true;
  72             }
  73         }
  74         return false;
  75     },
  76
  77     get_health_icon: function(state, circle) {
  78         if (circle === undefined) {
  79             circle = false;
  80         }
  81
  82         if (state === undefined) {
  83             state = 'uknown';
  84         }
  85
  86         var icon = 'faded fa-question';
  87         switch (state) {
  88             case 'good':
  89                 icon = 'good fa-check';
  90                 break;
  91             case 'upgrade':
  92                 icon = 'warning fa-upload';
  93                 break;
  94             case 'old':
  95                 icon = 'warning fa-refresh';
  96                 break;
  97             case 'warning':
  98                 icon = 'warning fa-exclamation';
  99                 break;
 100             case 'critical':
 101                 icon = 'critical fa-times';
 102                 break;
 103             default: break;
 104         }
 105
 106         if (circle) {
 107             icon += '-circle';
 108         }
 109
 110         return icon;
 111     },
 112
 113     parse_ceph_version: function(service) {
 114         if (service.ceph_version_short) {
 115             return service.ceph_version_short;
 116         }
 117
 118         if (service.ceph_version) {
 119             var match = service.ceph_version.match(/version (\d+(\.\d+)*)/);
 120             if (match) {
 121                 return match[1];
 122             }
 123         }
 124
 125         return undefined;
 126     },
 127
 128     compare_ceph_versions: function(a, b) {
 129         let avers = [];
 130         let bvers = [];
 131
 132         if (a === b) {
 133             return 0;
 134         }
 135
 136         if (Ext.isArray(a)) {
 137             avers = a.slice(); // copy array
 138         } else {
 139             avers = a.toString().split('.');
 140         }
 141
 142         if (Ext.isArray(b)) {
 143             bvers = b.slice(); // copy array
 144         } else {
 145             bvers = b.toString().split('.');
 146         }
 147
 148         for (;;) {
 149             let av = avers.shift();
 150             let bv = bvers.shift();
 151
 152             if (av === undefined && bv === undefined) {
 153                 return 0;
 154             } else if (av === undefined) {
 155                 return -1;
 156             } else if (bv === undefined) {
 157                 return 1;
 158             } else {
 159                 let diff = parseInt(av, 10) - parseInt(bv, 10);
 160                 if (diff !== 0) return diff;
 161                 // else we need to look at the next parts
 162             }
 163         }
 164     },
 165
 166     get_ceph_icon_html: function(health, fw) {
 167         var state = PVE.Utils.map_ceph_health[health];
 168         var cls = PVE.Utils.get_health_icon(state);
 169         if (fw) {
 170             cls += ' fa-fw';
 171         }
 172         return "<i class='fa " + cls + "'></i> ";
 173     },
 174
 175     map_ceph_health: {
 176         'HEALTH_OK': 'good',
 177         'HEALTH_UPGRADE': 'upgrade',
 178         'HEALTH_OLD': 'old',
 179         'HEALTH_WARN': 'warning',
 180         'HEALTH_ERR': 'critical',
 181     },
 182
 183     render_sdn_pending: function(rec, value, key, index) {
 184         if (rec.data.state === undefined || rec.data.state === null) {
 185             return value;
 186         }
 187
 188         if (rec.data.state === 'deleted') {
 189             if (value === undefined) {
 190                 return ' ';
 191             } else {
 192                 return '<div style="text-decoration: line-through;">'+ value +'</div>';
 193             }
 194         } else if (rec.data.pending[key] !== undefined && rec.data.pending[key] !== null) {
 195             if (rec.data.pending[key] === 'deleted') {
 196                 return ' ';
 197             } else {
 198                 return rec.data.pending[key];
 199             }
 200         }
 201         return value;
 202     },
 203
 204     render_sdn_pending_state: function(rec, value) {
 205         if (value === undefined || value === null) {
 206             return ' ';
 207         }
 208
 209         let icon = `<i class="fa fa-fw fa-refresh warning"></i>`;
 210
 211         if (value === 'deleted') {
 212             return '<span>' + icon + value + '</span>';
 213         }
 214
 215         let tip = gettext('Pending Changes') + ': <br>';
 216
 217         for (const [key, keyvalue] of Object.entries(rec.data.pending)) {
 218             if ((rec.data[key] !== undefined && rec.data.pending[key] !== rec.data[key]) ||
 219                 rec.data[key] === undefined
 220             ) {
 221                 tip += `${key}: ${keyvalue} <br>`;
 222             }
 223         }
 224         return '<span data-qtip="' + tip + '">'+ icon + value + '</span>';
 225     },
 226
 227     render_ceph_health: function(healthObj) {
 228         var state = {
 229             iconCls: PVE.Utils.get_health_icon(),
 230             text: '',
 231         };
 232
 233         if (!healthObj || !healthObj.status) {
 234             return state;
 235         }
 236
 237         var health = PVE.Utils.map_ceph_health[healthObj.status];
 238
 239         state.iconCls = PVE.Utils.get_health_icon(health, true);
 240         state.text = healthObj.status;
 241
 242         return state;
 243     },
 244
 245     render_zfs_health: function(value) {
 246         if (typeof value === 'undefined') {
 247             return "";
 248         }
 249         var iconCls = 'question-circle';
 250         switch (value) {
 251             case 'AVAIL':
 252             case 'ONLINE':
 253                 iconCls = 'check-circle good';
 254                 break;
 255             case 'REMOVED':
 256             case 'DEGRADED':
 257                 iconCls = 'exclamation-circle warning';
 258                 break;
 259             case 'UNAVAIL':
 260             case 'FAULTED':
 261             case 'OFFLINE':
 262                 iconCls = 'times-circle critical';
 263                 break;
 264             default: //unknown
 265         }
 266
 267         return '<i class="fa fa-' + iconCls + '"></i> ' + value;
 268     },
 269
 270     render_pbs_fingerprint: fp => fp.substring(0, 23),
 271
 272     render_backup_encryption: function(v, meta, record) {
 273         if (!v) {
 274             return gettext('No');
 275         }
 276
 277         let tip = '';
 278         if (v.match(/^[a-fA-F0-9]{2}:/)) { // fingerprint
 279             tip = `Key fingerprint ${PVE.Utils.render_pbs_fingerprint(v)}`;
 280         }
 281         let icon = `<i class="fa fa-fw fa-lock good"></i>`;
 282         return `<span data-qtip="${tip}">${icon} ${gettext('Encrypted')}</span>`;
 283     },
 284
 285     render_backup_verification: function(v, meta, record) {
 286         let i = (cls, txt) => `<i class="fa fa-fw fa-${cls}"></i> ${txt}`;
 287         if (v === undefined || v === null) {
 288             return i('question-circle-o warning', gettext('None'));
 289         }
 290         let tip = "";
 291         let txt = gettext('Failed');
 292         let iconCls = 'times critical';
 293         if (v.state === 'ok') {
 294             txt = gettext('OK');
 295             iconCls = 'check good';
 296             let now = Date.now() / 1000;
 297             let task = Proxmox.Utils.parse_task_upid(v.upid);
 298             let verify_time = Proxmox.Utils.render_timestamp(task.starttime);
 299             tip = `Last verify task started on ${verify_time}`;
 300             if (now - v.starttime > 30 * 24 * 60 * 60) {
 301                 tip = `Last verify task over 30 days ago: ${verify_time}`;
 302                 iconCls = 'check warning';
 303             }
 304         }
 305         return `<span data-qtip="${tip}"> ${i(iconCls, txt)} </span>`;
 306     },
 307
 308     render_backup_status: function(value, meta, record) {
 309         if (typeof value === 'undefined') {
 310             return "";
 311         }
 312
 313         let iconCls = 'check-circle good';
 314         let text = gettext('Yes');
 315
 316         if (!PVE.Parser.parseBoolean(value.toString())) {
 317             iconCls = 'times-circle critical';
 318
 319             text = gettext('No');
 320
 321             let reason = record.get('reason');
 322             if (typeof reason !== 'undefined') {
 323                 if (reason in PVE.Utils.backup_reasons_table) {
 324                     reason = PVE.Utils.backup_reasons_table[record.get('reason')];
 325                 }
 326                 text = `${text} - ${reason}`;
 327             }
 328         }
 329
 330         return `<i class="fa fa-${iconCls}"></i> ${text}`;
 331     },
 332
 333     render_backup_days_of_week: function(val) {
 334         var dows = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
 335         var selected = [];
 336         var cur = -1;
 337         val.split(',').forEach(function(day) {
 338             cur++;
 339             var dow = (dows.indexOf(day)+6)%7;
 340             if (cur === dow) {
 341                 if (selected.length === 0 || selected[selected.length-1] === 0) {
 342                     selected.push(1);
 343                 } else {
 344                     selected[selected.length-1]++;
 345                 }
 346             } else {
 347                 while (cur < dow) {
 348                     cur++;
 349                     selected.push(0);
 350                 }
 351                 selected.push(1);
 352             }
 353         });
 354
 355         cur = -1;
 356         var days = [];
 357         selected.forEach(function(item) {
 358             cur++;
 359             if (item > 2) {
 360                 days.push(Ext.Date.dayNames[cur+1] + '-' + Ext.Date.dayNames[(cur+item)%7]);
 361                 cur += item-1;
 362             } else if (item === 2) {
 363                 days.push(Ext.Date.dayNames[cur+1]);
 364                 days.push(Ext.Date.dayNames[(cur+2)%7]);
 365                 cur++;
 366             } else if (item === 1) {
 367                 days.push(Ext.Date.dayNames[(cur+1)%7]);
 368             }
 369         });
 370         return days.join(', ');
 371     },
 372
 373     render_backup_selection: function(value, metaData, record) {
 374         let allExceptText = gettext('All except {0}');
 375         let allText = '-- ' + gettext('All') + ' --';
 376         if (record.data.all) {
 377             if (record.data.exclude) {
 378                 return Ext.String.format(allExceptText, record.data.exclude);
 379             }
 380             return allText;
 381         }
 382         if (record.data.vmid) {
 383             return record.data.vmid;
 384         }
 385
 386         if (record.data.pool) {
 387             return "Pool '"+ record.data.pool + "'";
 388         }
 389
 390         return "-";
 391     },
 392
 393     backup_reasons_table: {
 394         'backup=yes': gettext('Enabled'),
 395         'backup=no': gettext('Disabled'),
 396         'enabled': gettext('Enabled'),
 397         'disabled': gettext('Disabled'),
 398         'not a volume': gettext('Not a volume'),
 399         'efidisk but no OMVF BIOS': gettext('EFI Disk without OMVF BIOS'),
 400     },
 401
 402     get_kvm_osinfo: function(value) {
 403         var info = { base: 'Other' }; // default
 404         if (value) {
 405             Ext.each(Object.keys(PVE.Utils.kvm_ostypes), function(k) {
 406                 Ext.each(PVE.Utils.kvm_ostypes[k], function(e) {
 407                     if (e.val === value) {
 408                         info = { desc: e.desc, base: k };
 409                     }
 410                 });
 411             });
 412         }
 413         return info;
 414     },
 415
 416     render_kvm_ostype: function(value) {
 417         var osinfo = PVE.Utils.get_kvm_osinfo(value);
 418         if (osinfo.desc && osinfo.desc !== '-') {
 419             return osinfo.base + ' ' + osinfo.desc;
 420         } else {
 421             return osinfo.base;
 422         }
 423     },
 424
 425     render_hotplug_features: function(value) {
 426         var fa = [];
 427
 428         if (!value || value === '0') {
 429             return gettext('Disabled');
 430         }
 431
 432         if (value === '1') {
 433             value = 'disk,network,usb';
 434         }
 435
 436         Ext.each(value.split(','), function(el) {
 437             if (el === 'disk') {
 438                 fa.push(gettext('Disk'));
 439             } else if (el === 'network') {
 440                 fa.push(gettext('Network'));
 441             } else if (el === 'usb') {
 442                 fa.push('USB');
 443             } else if (el === 'memory') {
 444                 fa.push(gettext('Memory'));
 445             } else if (el === 'cpu') {
 446                 fa.push(gettext('CPU'));
 447             } else {
 448                 fa.push(el);
 449             }
 450         });
 451
 452         return fa.join(', ');
 453     },
 454
 455     render_localtime: function(value) {
 456         if (value === '__default__') {
 457             return Proxmox.Utils.defaultText + ' (' + gettext('Enabled for Windows') + ')';
 458         }
 459         return Proxmox.Utils.format_boolean(value);
 460     },
 461
 462     render_qga_features: function(config) {
 463         if (!config) {
 464             return Proxmox.Utils.defaultText + ' (' + Proxmox.Utils.disabledText + ')';
 465         }
 466         let qga = PVE.Parser.parsePropertyString(config, 'enabled');
 467         if (!PVE.Parser.parseBoolean(qga.enabled)) {
 468             return Proxmox.Utils.disabledText;
 469         }
 470         delete qga.enabled;
 471
 472         let agentstring = Proxmox.Utils.enabledText;
 473
 474         for (const [key, value] of Object.entries(qga)) {
 475             let displayText = Proxmox.Utils.disabledText;
 476             if (key === 'type') {
 477                 let map = {
 478                     isa: "ISA",
 479                     virtio: "VirtIO",
 480                 };
 481                 displayText = map[value] || Proxmox.Utils.unknownText;
 482             } else if (PVE.Parser.parseBoolean(value)) {
 483                 displayText = Proxmox.Utils.enabledText;
 484             }
 485             agentstring += `, ${key}: ${displayText}`;
 486         }
 487
 488         return agentstring;
 489     },
 490
 491     render_qemu_machine: function(value) {
 492         return value || Proxmox.Utils.defaultText + ' (i440fx)';
 493     },
 494
 495     render_qemu_bios: function(value) {
 496         if (!value) {
 497             return Proxmox.Utils.defaultText + ' (SeaBIOS)';
 498         } else if (value === 'seabios') {
 499             return "SeaBIOS";
 500         } else if (value === 'ovmf') {
 501             return "OVMF (UEFI)";
 502         } else {
 503             return value;
 504         }
 505     },
 506
 507     render_dc_ha_opts: function(value) {
 508         if (!value) {
 509             return Proxmox.Utils.defaultText;
 510         } else {
 511             return PVE.Parser.printPropertyString(value);
 512         }
 513     },
 514     render_as_property_string: function(value) {
 515         return !value ? Proxmox.Utils.defaultText
 516             : PVE.Parser.printPropertyString(value);
 517     },
 518
 519     render_scsihw: function(value) {
 520         if (!value) {
 521             return Proxmox.Utils.defaultText + ' (LSI 53C895A)';
 522         } else if (value === 'lsi') {
 523             return 'LSI 53C895A';
 524         } else if (value === 'lsi53c810') {
 525             return 'LSI 53C810';
 526         } else if (value === 'megasas') {
 527             return 'MegaRAID SAS 8708EM2';
 528         } else if (value === 'virtio-scsi-pci') {
 529             return 'VirtIO SCSI';
 530         } else if (value === 'virtio-scsi-single') {
 531             return 'VirtIO SCSI single';
 532         } else if (value === 'pvscsi') {
 533             return 'VMware PVSCSI';
 534         } else {
 535             return value;
 536         }
 537     },
 538
 539     render_spice_enhancements: function(values) {
 540         let props = PVE.Parser.parsePropertyString(values);
 541         if (Ext.Object.isEmpty(props)) {
 542             return Proxmox.Utils.noneText;
 543         }
 544
 545         let output = [];
 546         if (PVE.Parser.parseBoolean(props.foldersharing)) {
 547             output.push('Folder Sharing: ' + gettext('Enabled'));
 548         }
 549         if (props.videostreaming === 'all' || props.videostreaming === 'filter') {
 550             output.push('Video Streaming: ' + props.videostreaming);
 551         }
 552         return output.join(', ');
 553     },
 554
 555     // fixme: auto-generate this
 556     // for now, please keep in sync with PVE::Tools::kvmkeymaps
 557     kvm_keymaps: {
 558         //ar: 'Arabic',
 559         da: 'Danish',
 560         de: 'German',
 561         'de-ch': 'German (Swiss)',
 562         'en-gb': 'English (UK)',
 563         'en-us': 'English (USA)',
 564         es: 'Spanish',
 565         //et: 'Estonia',
 566         fi: 'Finnish',
 567         //fo: 'Faroe Islands',
 568         fr: 'French',
 569         'fr-be': 'French (Belgium)',
 570         'fr-ca': 'French (Canada)',
 571         'fr-ch': 'French (Swiss)',
 572         //hr: 'Croatia',
 573         hu: 'Hungarian',
 574         is: 'Icelandic',
 575         it: 'Italian',
 576         ja: 'Japanese',
 577         lt: 'Lithuanian',
 578         //lv: 'Latvian',
 579         mk: 'Macedonian',
 580         nl: 'Dutch',
 581         //'nl-be': 'Dutch (Belgium)',
 582         no: 'Norwegian',
 583         pl: 'Polish',
 584         pt: 'Portuguese',
 585         'pt-br': 'Portuguese (Brazil)',
 586         //ru: 'Russian',
 587         sl: 'Slovenian',
 588         sv: 'Swedish',
 589         //th: 'Thai',
 590         tr: 'Turkish',
 591     },
 592
 593     kvm_vga_drivers: {
 594         std: gettext('Standard VGA'),
 595         vmware: gettext('VMware compatible'),
 596         qxl: 'SPICE',
 597         qxl2: 'SPICE dual monitor',
 598         qxl3: 'SPICE three monitors',
 599         qxl4: 'SPICE four monitors',
 600         serial0: gettext('Serial terminal') + ' 0',
 601         serial1: gettext('Serial terminal') + ' 1',
 602         serial2: gettext('Serial terminal') + ' 2',
 603         serial3: gettext('Serial terminal') + ' 3',
 604         virtio: 'VirtIO-GPU',
 605         none: Proxmox.Utils.noneText,
 606     },
 607
 608     render_kvm_language: function(value) {
 609         if (!value || value === '__default__') {
 610             return Proxmox.Utils.defaultText;
 611         }
 612         var text = PVE.Utils.kvm_keymaps[value];
 613         if (text) {
 614             return text + ' (' + value + ')';
 615         }
 616         return value;
 617     },
 618
 619     kvm_keymap_array: function() {
 620         var data = [['__default__', PVE.Utils.render_kvm_language('')]];
 621         Ext.Object.each(PVE.Utils.kvm_keymaps, function(key, value) {
 622             data.push([key, PVE.Utils.render_kvm_language(value)]);
 623         });
 624
 625         return data;
 626     },
 627
 628     console_map: {
 629         '__default__': Proxmox.Utils.defaultText + ' (xterm.js)',
 630         'vv': 'SPICE (remote-viewer)',
 631         'html5': 'HTML5 (noVNC)',
 632         'xtermjs': 'xterm.js',
 633     },
 634
 635     render_console_viewer: function(value) {
 636         value = value || '__default__';
 637         if (PVE.Utils.console_map[value]) {
 638             return PVE.Utils.console_map[value];
 639         }
 640         return value;
 641     },
 642
 643     console_viewer_array: function() {
 644         return Ext.Array.map(Object.keys(PVE.Utils.console_map), function(v) {
 645             return [v, PVE.Utils.render_console_viewer(v)];
 646         });
 647     },
 648
 649     render_kvm_vga_driver: function(value) {
 650         if (!value) {
 651             return Proxmox.Utils.defaultText;
 652         }
 653         var vga = PVE.Parser.parsePropertyString(value, 'type');
 654         var text = PVE.Utils.kvm_vga_drivers[vga.type];
 655         if (!vga.type) {
 656             text = Proxmox.Utils.defaultText;
 657         }
 658         if (text) {
 659             return text + ' (' + value + ')';
 660         }
 661         return value;
 662     },
 663
 664     kvm_vga_driver_array: function() {
 665         var data = [['__default__', PVE.Utils.render_kvm_vga_driver('')]];
 666         Ext.Object.each(PVE.Utils.kvm_vga_drivers, function(key, value) {
 667             data.push([key, PVE.Utils.render_kvm_vga_driver(value)]);
 668         });
 669
 670         return data;
 671     },
 672
 673     render_kvm_startup: function(value) {
 674         var startup = PVE.Parser.parseStartup(value);
 675
 676         var res = 'order=';
 677         if (startup.order === undefined) {
 678             res += 'any';
 679         } else {
 680             res += startup.order;
 681         }
 682         if (startup.up !== undefined) {
 683             res += ',up=' + startup.up;
 684         }
 685         if (startup.down !== undefined) {
 686             res += ',down=' + startup.down;
 687         }
 688
 689         return res;
 690     },
 691
 692     extractFormActionError: function(action) {
 693         var msg;
 694         switch (action.failureType) {
 695         case Ext.form.action.Action.CLIENT_INVALID:
 696             msg = gettext('Form fields may not be submitted with invalid values');
 697             break;
 698         case Ext.form.action.Action.CONNECT_FAILURE:
 699             msg = gettext('Connection error');
 700             var resp = action.response;
 701             if (resp.status && resp.statusText) {
 702                 msg += " " + resp.status + ": " + resp.statusText;
 703             }
 704             break;
 705         case Ext.form.action.Action.LOAD_FAILURE:
 706         case Ext.form.action.Action.SERVER_INVALID:
 707             msg = Proxmox.Utils.extractRequestError(action.result, true);
 708             break;
 709         }
 710         return msg;
 711     },
 712
 713     contentTypes: {
 714         'images': gettext('Disk image'),
 715         'backup': gettext('VZDump backup file'),
 716         'vztmpl': gettext('Container template'),
 717         'iso': gettext('ISO image'),
 718         'rootdir': gettext('Container'),
 719         'snippets': gettext('Snippets'),
 720     },
 721
 722     volume_is_qemu_backup: function(volid, format) {
 723         return format === 'pbs-vm' || volid.match(':backup/vzdump-qemu-');
 724     },
 725
 726     volume_is_lxc_backup: function(volid, format) {
 727         return format === 'pbs-ct' || volid.match(':backup/vzdump-(lxc|openvz)-');
 728     },
 729
 730     authSchema: {
 731         ad: {
 732             name: gettext('Active Directory Server'),
 733             ipanel: 'pveAuthADPanel',
 734             syncipanel: 'pveAuthLDAPSyncPanel',
 735             add: true,
 736             tfa: true,
 737             pwchange: true,
 738         },
 739         ldap: {
 740             name: gettext('LDAP Server'),
 741             ipanel: 'pveAuthLDAPPanel',
 742             syncipanel: 'pveAuthLDAPSyncPanel',
 743             add: true,
 744             tfa: true,
 745             pwchange: true,
 746         },
 747         openid: {
 748             name: gettext('OpenID Server'),
 749             ipanel: 'pveAuthOpenIDPanel',
 750             add: true,
 751             tfa: false,
 752             pwchange: false,
 753             iconCls: 'pmx-itype-icon-openid-logo',
 754         },
 755         pam: {
 756             name: 'Linux PAM',
 757             ipanel: 'pveAuthBasePanel',
 758             add: false,
 759             tfa: true,
 760             pwchange: true,
 761         },
 762         pve: {
 763             name: 'Proxmox VE authentication server',
 764             ipanel: 'pveAuthBasePanel',
 765             add: false,
 766             pwchange: true,
 767         },
 768     },
 769
 770     storageSchema: {
 771         dir: {
 772             name: Proxmox.Utils.directoryText,
 773             ipanel: 'DirInputPanel',
 774             faIcon: 'folder',
 775             backups: true,
 776         },
 777         lvm: {
 778             name: 'LVM',
 779             ipanel: 'LVMInputPanel',
 780             faIcon: 'folder',
 781             backups: false,
 782         },
 783         lvmthin: {
 784             name: 'LVM-Thin',
 785             ipanel: 'LvmThinInputPanel',
 786             faIcon: 'folder',
 787             backups: false,
 788         },
 789         btrfs: {
 790             name: 'BTRFS',
 791             ipanel: 'BTRFSInputPanel',
 792             faIcon: 'folder',
 793             backups: true,
 794         },
 795         nfs: {
 796             name: 'NFS',
 797             ipanel: 'NFSInputPanel',
 798             faIcon: 'building',
 799             backups: true,
 800         },
 801         cifs: {
 802             name: 'CIFS',
 803             ipanel: 'CIFSInputPanel',
 804             faIcon: 'building',
 805             backups: true,
 806         },
 807         glusterfs: {
 808             name: 'GlusterFS',
 809             ipanel: 'GlusterFsInputPanel',
 810             faIcon: 'building',
 811             backups: true,
 812         },
 813         iscsi: {
 814             name: 'iSCSI',
 815             ipanel: 'IScsiInputPanel',
 816             faIcon: 'building',
 817             backups: false,
 818         },
 819         cephfs: {
 820             name: 'CephFS',
 821             ipanel: 'CephFSInputPanel',
 822             faIcon: 'building',
 823             backups: true,
 824         },
 825         pvecephfs: {
 826             name: 'CephFS (PVE)',
 827             ipanel: 'CephFSInputPanel',
 828             hideAdd: true,
 829             faIcon: 'building',
 830             backups: true,
 831         },
 832         rbd: {
 833             name: 'RBD',
 834             ipanel: 'RBDInputPanel',
 835             faIcon: 'building',
 836             backups: false,
 837         },
 838         pveceph: {
 839             name: 'RBD (PVE)',
 840             ipanel: 'RBDInputPanel',
 841             hideAdd: true,
 842             faIcon: 'building',
 843             backups: false,
 844         },
 845         zfs: {
 846             name: 'ZFS over iSCSI',
 847             ipanel: 'ZFSInputPanel',
 848             faIcon: 'building',
 849             backups: false,
 850         },
 851         zfspool: {
 852             name: 'ZFS',
 853             ipanel: 'ZFSPoolInputPanel',
 854             faIcon: 'folder',
 855             backups: false,
 856         },
 857         pbs: {
 858             name: 'Proxmox Backup Server',
 859             ipanel: 'PBSInputPanel',
 860             faIcon: 'floppy-o',
 861             backups: true,
 862         },
 863         drbd: {
 864             name: 'DRBD',
 865             hideAdd: true,
 866             backups: false,
 867         },
 868     },
 869
 870     sdnvnetSchema: {
 871         vnet: {
 872             name: 'vnet',
 873             faIcon: 'folder',
 874         },
 875     },
 876
 877     sdnzoneSchema: {
 878         zone: {
 879              name: 'zone',
 880              hideAdd: true,
 881         },
 882         simple: {
 883             name: 'Simple',
 884             ipanel: 'SimpleInputPanel',
 885             faIcon: 'th',
 886         },
 887         vlan: {
 888             name: 'VLAN',
 889             ipanel: 'VlanInputPanel',
 890             faIcon: 'th',
 891         },
 892         qinq: {
 893             name: 'QinQ',
 894             ipanel: 'QinQInputPanel',
 895             faIcon: 'th',
 896         },
 897         vxlan: {
 898             name: 'VXLAN',
 899             ipanel: 'VxlanInputPanel',
 900             faIcon: 'th',
 901         },
 902         evpn: {
 903             name: 'EVPN',
 904             ipanel: 'EvpnInputPanel',
 905             faIcon: 'th',
 906         },
 907     },
 908
 909     sdncontrollerSchema: {
 910         controller: {
 911              name: 'controller',
 912              hideAdd: true,
 913         },
 914         evpn: {
 915             name: 'evpn',
 916             ipanel: 'EvpnInputPanel',
 917             faIcon: 'crosshairs',
 918         },
 919         bgp: {
 920             name: 'bgp',
 921             ipanel: 'BgpInputPanel',
 922             faIcon: 'crosshairs',
 923         },
 924     },
 925
 926     sdnipamSchema: {
 927         ipam: {
 928              name: 'ipam',
 929              hideAdd: true,
 930         },
 931         pve: {
 932             name: 'PVE',
 933             ipanel: 'PVEIpamInputPanel',
 934             faIcon: 'th',
 935             hideAdd: true,
 936         },
 937         netbox: {
 938             name: 'Netbox',
 939             ipanel: 'NetboxInputPanel',
 940             faIcon: 'th',
 941         },
 942         phpipam: {
 943             name: 'PhpIpam',
 944             ipanel: 'PhpIpamInputPanel',
 945             faIcon: 'th',
 946         },
 947     },
 948
 949     sdndnsSchema: {
 950         dns: {
 951              name: 'dns',
 952              hideAdd: true,
 953         },
 954         powerdns: {
 955             name: 'powerdns',
 956             ipanel: 'PowerdnsInputPanel',
 957             faIcon: 'th',
 958         },
 959     },
 960
 961     format_sdnvnet_type: function(value, md, record) {
 962         var schema = PVE.Utils.sdnvnetSchema[value];
 963         if (schema) {
 964             return schema.name;
 965         }
 966         return Proxmox.Utils.unknownText;
 967     },
 968
 969     format_sdnzone_type: function(value, md, record) {
 970         var schema = PVE.Utils.sdnzoneSchema[value];
 971         if (schema) {
 972             return schema.name;
 973         }
 974         return Proxmox.Utils.unknownText;
 975     },
 976
 977     format_sdncontroller_type: function(value, md, record) {
 978         var schema = PVE.Utils.sdncontrollerSchema[value];
 979         if (schema) {
 980             return schema.name;
 981         }
 982         return Proxmox.Utils.unknownText;
 983     },
 984
 985     format_sdnipam_type: function(value, md, record) {
 986         var schema = PVE.Utils.sdnipamSchema[value];
 987         if (schema) {
 988             return schema.name;
 989         }
 990         return Proxmox.Utils.unknownText;
 991     },
 992
 993     format_sdndns_type: function(value, md, record) {
 994         var schema = PVE.Utils.sdndnsSchema[value];
 995         if (schema) {
 996             return schema.name;
 997         }
 998         return Proxmox.Utils.unknownText;
 999     },
1000
1001     format_storage_type: function(value, md, record) {
1002         if (value === 'rbd') {
1003             value = !record || record.get('monhost') ? 'rbd' : 'pveceph';
1004         } else if (value === 'cephfs') {
1005             value = !record || record.get('monhost') ? 'cephfs' : 'pvecephfs';
1006         }
1007
1008         var schema = PVE.Utils.storageSchema[value];
1009         if (schema) {
1010             return schema.name;
1011         }
1012         return Proxmox.Utils.unknownText;
1013     },
1014
1015     format_ha: function(value) {
1016         var text = Proxmox.Utils.noneText;
1017
1018         if (value.managed) {
1019             text = value.state || Proxmox.Utils.noneText;
1020
1021             text += ', ' + Proxmox.Utils.groupText + ': ';
1022             text += value.group || Proxmox.Utils.noneText;
1023         }
1024
1025         return text;
1026     },
1027
1028     format_content_types: function(value) {
1029         return value.split(',').sort().map(function(ct) {
1030             return PVE.Utils.contentTypes[ct] || ct;
1031         }).join(', ');
1032     },
1033
1034     render_storage_content: function(value, metaData, record) {
1035         var data = record.data;
1036         if (Ext.isNumber(data.channel) &&
1037             Ext.isNumber(data.id) &&
1038             Ext.isNumber(data.lun)) {
1039             return "CH " +
1040                 Ext.String.leftPad(data.channel, 2, '0') +
1041                 " ID " + data.id + " LUN " + data.lun;
1042         }
1043         return data.volid.replace(/^.*?:(.*?\/)?/, '');
1044     },
1045
1046     render_serverity: function(value) {
1047         return PVE.Utils.log_severity_hash[value] || value;
1048     },
1049
1050     calculate_hostcpu: function(data) {
1051         if (!(data.uptime && Ext.isNumeric(data.cpu))) {
1052             return -1;
1053         }
1054
1055         if (data.type !== 'qemu' && data.type !== 'lxc') {
1056             return -1;
1057         }
1058
1059         var index = PVE.data.ResourceStore.findExact('id', 'node/' + data.node);
1060         var node = PVE.data.ResourceStore.getAt(index);
1061         if (!Ext.isDefined(node) || node === null) {
1062             return -1;
1063         }
1064         var maxcpu = node.data.maxcpu || 1;
1065
1066         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
1067             return -1;
1068         }
1069
1070         return (data.cpu/maxcpu) * data.maxcpu;
1071     },
1072
1073     render_hostcpu: function(value, metaData, record, rowIndex, colIndex, store) {
1074         if (!(record.data.uptime && Ext.isNumeric(record.data.cpu))) {
1075             return '';
1076         }
1077
1078         if (record.data.type !== 'qemu' && record.data.type !== 'lxc') {
1079             return '';
1080         }
1081
1082         var index = PVE.data.ResourceStore.findExact('id', 'node/' + record.data.node);
1083         var node = PVE.data.ResourceStore.getAt(index);
1084         if (!Ext.isDefined(node) || node === null) {
1085             return '';
1086         }
1087         var maxcpu = node.data.maxcpu || 1;
1088
1089         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
1090             return '';
1091         }
1092
1093         var per = (record.data.cpu/maxcpu) * record.data.maxcpu * 100;
1094
1095         return per.toFixed(1) + '% of ' + maxcpu.toString() + (maxcpu > 1 ? 'CPUs' : 'CPU');
1096     },
1097
1098     render_bandwidth: function(value) {
1099         if (!Ext.isNumeric(value)) {
1100             return '';
1101         }
1102
1103         return Proxmox.Utils.format_size(value) + '/s';
1104     },
1105
1106     render_timestamp_human_readable: function(value) {
1107         return Ext.Date.format(new Date(value * 1000), 'l d F Y H:i:s');
1108     },
1109
1110     calculate_mem_usage: function(data) {
1111         if (!Ext.isNumeric(data.mem) ||
1112             data.maxmem === 0 ||
1113             data.uptime < 1) {
1114             return -1;
1115         }
1116
1117         return data.mem / data.maxmem;
1118     },
1119
1120     calculate_hostmem_usage: function(data) {
1121         if (data.type !== 'qemu' && data.type !== 'lxc') {
1122             return -1;
1123         }
1124
1125         var index = PVE.data.ResourceStore.findExact('id', 'node/' + data.node);
1126         var node = PVE.data.ResourceStore.getAt(index);
1127
1128         if (!Ext.isDefined(node) || node === null) {
1129             return -1;
1130         }
1131         var maxmem = node.data.maxmem || 0;
1132
1133         if (!Ext.isNumeric(data.mem) ||
1134             maxmem === 0 ||
1135             data.uptime < 1) {
1136             return -1;
1137         }
1138
1139         return data.mem / maxmem;
1140     },
1141
1142     render_mem_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1143         if (!Ext.isNumeric(value) || value === -1) {
1144             return '';
1145         }
1146         if (value > 1) {
1147             // we got no percentage but bytes
1148             var mem = value;
1149             var maxmem = record.data.maxmem;
1150             if (!record.data.uptime ||
1151                 maxmem === 0 ||
1152                 !Ext.isNumeric(mem)) {
1153                 return '';
1154             }
1155
1156             return (mem*100/maxmem).toFixed(1) + " %";
1157         }
1158         return (value*100).toFixed(1) + " %";
1159     },
1160
1161     render_hostmem_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1162         if (!Ext.isNumeric(record.data.mem) || value === -1) {
1163             return '';
1164         }
1165
1166         if (record.data.type !== 'qemu' && record.data.type !== 'lxc') {
1167             return '';
1168         }
1169
1170         var index = PVE.data.ResourceStore.findExact('id', 'node/' + record.data.node);
1171         var node = PVE.data.ResourceStore.getAt(index);
1172         var maxmem = node.data.maxmem || 0;
1173
1174         if (record.data.mem > 1) {
1175             // we got no percentage but bytes
1176             var mem = record.data.mem;
1177             if (!record.data.uptime ||
1178                 maxmem === 0 ||
1179                 !Ext.isNumeric(mem)) {
1180                 return '';
1181             }
1182
1183             return ((mem*100)/maxmem).toFixed(1) + " %";
1184         }
1185         return (value*100).toFixed(1) + " %";
1186     },
1187
1188     render_mem_usage: function(value, metaData, record, rowIndex, colIndex, store) {
1189         var mem = value;
1190         var maxmem = record.data.maxmem;
1191
1192         if (!record.data.uptime) {
1193             return '';
1194         }
1195
1196         if (!(Ext.isNumeric(mem) && maxmem)) {
1197             return '';
1198         }
1199
1200         return Proxmox.Utils.render_size(value);
1201     },
1202
1203     calculate_disk_usage: function(data) {
1204         if (!Ext.isNumeric(data.disk) ||
1205             ((data.type === 'qemu' || data.type === 'lxc') && data.uptime === 0) ||
1206             data.maxdisk === 0
1207         ) {
1208             return -1;
1209         }
1210
1211         return data.disk / data.maxdisk;
1212     },
1213
1214     render_disk_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1215         if (!Ext.isNumeric(value) || value === -1) {
1216             return '';
1217         }
1218
1219         return (value * 100).toFixed(1) + " %";
1220     },
1221
1222     render_disk_usage: function(value, metaData, record, rowIndex, colIndex, store) {
1223         var disk = value;
1224         var maxdisk = record.data.maxdisk;
1225         var type = record.data.type;
1226
1227         if (!Ext.isNumeric(disk) ||
1228             maxdisk === 0 ||
1229             ((type === 'qemu' || type === 'lxc') && record.data.uptime === 0)
1230         ) {
1231             return '';
1232         }
1233
1234         return Proxmox.Utils.render_size(value);
1235     },
1236
1237     get_object_icon_class: function(type, record) {
1238         var status = '';
1239         var objType = type;
1240
1241         if (type === 'type') {
1242             // for folder view
1243             objType = record.groupbyid;
1244         } else if (record.template) {
1245             // templates
1246             objType = 'template';
1247             status = type;
1248         } else {
1249             // everything else
1250             status = record.status + ' ha-' + record.hastate;
1251         }
1252
1253         if (record.lock) {
1254             status += ' locked lock-' + record.lock;
1255         }
1256
1257         var defaults = PVE.tree.ResourceTree.typeDefaults[objType];
1258         if (defaults && defaults.iconCls) {
1259             var retVal = defaults.iconCls + ' ' + status;
1260             return retVal;
1261         }
1262
1263         return '';
1264     },
1265
1266     render_resource_type: function(value, metaData, record, rowIndex, colIndex, store) {
1267         var cls = PVE.Utils.get_object_icon_class(value, record.data);
1268
1269         var fa = '<i class="fa-fw x-grid-icon-custom ' + cls + '"></i> ';
1270         return fa + value;
1271     },
1272
1273     render_support_level: function(value, metaData, record) {
1274         return PVE.Utils.support_level_hash[value] || '-';
1275     },
1276
1277     render_upid: function(value, metaData, record) {
1278         var type = record.data.type;
1279         var id = record.data.id;
1280
1281         return Proxmox.Utils.format_task_description(type, id);
1282     },
1283
1284     render_optional_url: function(value) {
1285         if (value && value.match(/^https?:\/\//)) {
1286             return '<a target="_blank" href="' + value + '">' + value + '</a>';
1287         }
1288         return value;
1289     },
1290
1291     render_san: function(value) {
1292         var names = [];
1293         if (Ext.isArray(value)) {
1294             value.forEach(function(val) {
1295                 if (!Ext.isNumber(val)) {
1296                     names.push(val);
1297                 }
1298             });
1299             return names.join('<br>');
1300         }
1301         return value;
1302     },
1303
1304     render_full_name: function(firstname, metaData, record) {
1305         var first = firstname || '';
1306         var last = record.data.lastname || '';
1307         return Ext.htmlEncode(first + " " + last);
1308     },
1309
1310     render_u2f_error: function(error) {
1311         var ErrorNames = {
1312             '1': gettext('Other Error'),
1313             '2': gettext('Bad Request'),
1314             '3': gettext('Configuration Unsupported'),
1315             '4': gettext('Device Ineligible'),
1316             '5': gettext('Timeout'),
1317         };
1318         return "U2F Error: " + ErrorNames[error] || Proxmox.Utils.unknownText;
1319     },
1320
1321     windowHostname: function() {
1322         return window.location.hostname.replace(Proxmox.Utils.IP6_bracket_match,
1323             function(m, addr, offset, original) { return addr; });
1324     },
1325
1326     openDefaultConsoleWindow: function(consoles, consoleType, vmid, nodename, vmname, cmd) {
1327         var dv = PVE.Utils.defaultViewer(consoles, consoleType);
1328         PVE.Utils.openConsoleWindow(dv, consoleType, vmid, nodename, vmname, cmd);
1329     },
1330
1331     openConsoleWindow: function(viewer, consoleType, vmid, nodename, vmname, cmd) {
1332         if (vmid === undefined && (consoleType === 'kvm' || consoleType === 'lxc')) {
1333             throw "missing vmid";
1334         }
1335         if (!nodename) {
1336             throw "no nodename specified";
1337         }
1338
1339         if (viewer === 'html5') {
1340             PVE.Utils.openVNCViewer(consoleType, vmid, nodename, vmname, cmd);
1341         } else if (viewer === 'xtermjs') {
1342             Proxmox.Utils.openXtermJsViewer(consoleType, vmid, nodename, vmname, cmd);
1343         } else if (viewer === 'vv') {
1344             let url = '/nodes/' + nodename + '/spiceshell';
1345             let params = {
1346                 proxy: PVE.Utils.windowHostname(),
1347             };
1348             if (consoleType === 'kvm') {
1349                 url = '/nodes/' + nodename + '/qemu/' + vmid.toString() + '/spiceproxy';
1350             } else if (consoleType === 'lxc') {
1351                 url = '/nodes/' + nodename + '/lxc/' + vmid.toString() + '/spiceproxy';
1352             } else if (consoleType === 'upgrade') {
1353                 params.cmd = 'upgrade';
1354             } else if (consoleType === 'cmd') {
1355                 params.cmd = cmd;
1356             } else if (consoleType !== 'shell') {
1357                 throw `unknown spice viewer type '${consoleType}'`;
1358             }
1359             PVE.Utils.openSpiceViewer(url, params);
1360         } else {
1361             throw `unknown viewer type '${viewer}'`;
1362         }
1363     },
1364
1365     defaultViewer: function(consoles, type) {
1366         var allowSpice, allowXtermjs;
1367
1368         if (consoles === true) {
1369             allowSpice = true;
1370             allowXtermjs = true;
1371         } else if (typeof consoles === 'object') {
1372             allowSpice = consoles.spice;
1373             allowXtermjs = !!consoles.xtermjs;
1374         }
1375         let dv = PVE.VersionInfo.console || (type === 'kvm' ? 'vv' : 'xtermjs');
1376         if (dv === 'vv' && !allowSpice) {
1377             dv = allowXtermjs ? 'xtermjs' : 'html5';
1378         } else if (dv === 'xtermjs' && !allowXtermjs) {
1379             dv = allowSpice ? 'vv' : 'html5';
1380         }
1381
1382         return dv;
1383     },
1384
1385     openVNCViewer: function(vmtype, vmid, nodename, vmname, cmd) {
1386         let scaling = 'off';
1387         if (Proxmox.Utils.toolkit !== 'touch') {
1388             var sp = Ext.state.Manager.getProvider();
1389             scaling = sp.get('novnc-scaling', 'off');
1390         }
1391         var url = Ext.Object.toQueryString({
1392             console: vmtype, // kvm, lxc, upgrade or shell
1393             novnc: 1,
1394             vmid: vmid,
1395             vmname: vmname,
1396             node: nodename,
1397             resize: scaling,
1398             cmd: cmd,
1399         });
1400         var nw = window.open("?" + url, '_blank', "innerWidth=745,innerheight=427");
1401         if (nw) {
1402             nw.focus();
1403         }
1404     },
1405
1406     openSpiceViewer: function(url, params) {
1407         var downloadWithName = function(uri, name) {
1408             var link = Ext.DomHelper.append(document.body, {
1409                 tag: 'a',
1410                 href: uri,
1411                 css: 'display:none;visibility:hidden;height:0px;',
1412             });
1413
1414             // Note: we need to tell Android and Chrome the correct file name extension
1415             // but we do not set 'download' tag for other environments, because
1416             // It can have strange side effects (additional user prompt on firefox)
1417             if (navigator.userAgent.match(/Android|Chrome/i)) {
1418                 link.download = name;
1419             }
1420
1421             if (link.fireEvent) {
1422                 link.fireEvent('onclick');
1423             } else {
1424                 let evt = document.createEvent("MouseEvents");
1425                 evt.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
1426                 link.dispatchEvent(evt);
1427             }
1428         };
1429
1430         Proxmox.Utils.API2Request({
1431             url: url,
1432             params: params,
1433             method: 'POST',
1434             failure: function(response, opts) {
1435                 Ext.Msg.alert('Error', response.htmlStatus);
1436             },
1437             success: function(response, opts) {
1438                 let cfg = response.result.data;
1439                 let raw = Object.entries(cfg).reduce((acc, [k, v]) => acc + `${k}=${v}\n`, "[virt-viewer]\n");
1440                 let spiceDownload = 'data:application/x-virt-viewer;charset=UTF-8,' + encodeURIComponent(raw);
1441                 downloadWithName(spiceDownload, "pve-spice.vv");
1442             },
1443         });
1444     },
1445
1446     openTreeConsole: function(tree, record, item, index, e) {
1447         e.stopEvent();
1448         let nodename = record.data.node;
1449         let vmid = record.data.vmid;
1450         let vmname = record.data.name;
1451         if (record.data.type === 'qemu' && !record.data.template) {
1452             Proxmox.Utils.API2Request({
1453                 url: `/nodes/${nodename}/qemu/${vmid}/status/current`,
1454                 failure: response => Ext.Msg.alert('Error', response.htmlStatus),
1455                 success: function(response, opts) {
1456                     let conf = response.result.data;
1457                     let consoles = {
1458                         spice: !!conf.spice,
1459                         xtermjs: !!conf.serial,
1460                     };
1461                     PVE.Utils.openDefaultConsoleWindow(consoles, 'kvm', vmid, nodename, vmname);
1462                 },
1463             });
1464         } else if (record.data.type === 'lxc' && !record.data.template) {
1465             PVE.Utils.openDefaultConsoleWindow(true, 'lxc', vmid, nodename, vmname);
1466         }
1467     },
1468
1469     // test automation helper
1470     call_menu_handler: function(menu, text) {
1471         let item = menu.query('menuitem').find(el => el.text === text);
1472         if (item && item.handler) {
1473             item.handler();
1474         }
1475     },
1476
1477     createCmdMenu: function(v, record, item, index, event) {
1478         event.stopEvent();
1479         if (!(v instanceof Ext.tree.View)) {
1480             v.select(record);
1481         }
1482         let menu;
1483         let type = record.data.type;
1484
1485         if (record.data.template) {
1486             if (type === 'qemu' || type === 'lxc') {
1487                 menu = Ext.create('PVE.menu.TemplateMenu', {
1488                     pveSelNode: record,
1489                 });
1490             }
1491         } else if (type === 'qemu' || type === 'lxc' || type === 'node') {
1492             menu = Ext.create('PVE.' + type + '.CmdMenu', {
1493                 pveSelNode: record,
1494                 nodename: record.data.node,
1495             });
1496         } else {
1497             return undefined;
1498         }
1499
1500         menu.showAt(event.getXY());
1501         return menu;
1502     },
1503
1504     // helper for deleting field which are set to there default values
1505     delete_if_default: function(values, fieldname, default_val, create) {
1506         if (values[fieldname] === '' || values[fieldname] === default_val) {
1507             if (!create) {
1508                 if (values.delete) {
1509                     if (Ext.isArray(values.delete)) {
1510                         values.delete.push(fieldname);
1511                     } else {
1512                         values.delete += ',' + fieldname;
1513                     }
1514                 } else {
1515                     values.delete = fieldname;
1516                 }
1517             }
1518
1519             delete values[fieldname];
1520         }
1521     },
1522
1523     loadSSHKeyFromFile: function(file, callback) {
1524         // ssh-keygen produces ~ 740 bytes for a 4096 bit RSA key,  current max is 16 kbit, so assume:
1525         // 740 * 8 for max. 32kbit (5920 bytes), round upwards to 8192 bytes, leaves lots of comment space
1526         PVE.Utils.loadFile(file, callback, 8192);
1527     },
1528
1529     loadFile: function(file, callback, maxSize) {
1530         maxSize = maxSize || 32 * 1024;
1531         if (file.size > maxSize) {
1532             Ext.Msg.alert(gettext('Error'), `${gettext("Invalid file size")}: ${file.size} > ${maxSize}`);
1533             return;
1534         }
1535         let reader = new FileReader();
1536         reader.onload = evt => callback(evt.target.result);
1537         reader.readAsText(file);
1538     },
1539
1540     loadTextFromFile: function(file, callback, maxBytes) {
1541         let maxSize = maxBytes || 8192;
1542         if (file.size > maxSize) {
1543             Ext.Msg.alert(gettext('Error'), gettext("Invalid file size: ") + file.size);
1544             return;
1545         }
1546         let reader = new FileReader();
1547         reader.onload = evt => callback(evt.target.result);
1548         reader.readAsText(file);
1549     },
1550
1551     diskControllerMaxIDs: {
1552         ide: 4,
1553         sata: 6,
1554         scsi: 31,
1555         virtio: 16,
1556     },
1557
1558     // types is either undefined (all busses), an array of busses, or a single bus
1559     forEachBus: function(types, func) {
1560         let busses = Object.keys(PVE.Utils.diskControllerMaxIDs);
1561
1562         if (Ext.isArray(types)) {
1563             busses = types;
1564         } else if (Ext.isDefined(types)) {
1565             busses = [types];
1566         }
1567
1568         // check if we only have valid busses
1569         for (let i = 0; i < busses.length; i++) {
1570             if (!PVE.Utils.diskControllerMaxIDs[busses[i]]) {
1571                 throw "invalid bus: '" + busses[i] + "'";
1572             }
1573         }
1574
1575         for (let i = 0; i < busses.length; i++) {
1576             let count = PVE.Utils.diskControllerMaxIDs[busses[i]];
1577             for (let j = 0; j < count; j++) {
1578                 let cont = func(busses[i], j);
1579                 if (!cont && cont !== undefined) {
1580                     return;
1581                 }
1582             }
1583         }
1584     },
1585
1586     mp_counts: {
1587         mps: 256,
1588         unused: 256,
1589     },
1590
1591     forEachMP: function(func, includeUnused) {
1592         for (let i = 0; i < PVE.Utils.mp_counts.mps; i++) {
1593             let cont = func('mp', i);
1594             if (!cont && cont !== undefined) {
1595                 return;
1596             }
1597         }
1598
1599         if (!includeUnused) {
1600             return;
1601         }
1602
1603         for (let i = 0; i < PVE.Utils.mp_counts.unused; i++) {
1604             let cont = func('unused', i);
1605             if (!cont && cont !== undefined) {
1606                 return;
1607             }
1608         }
1609     },
1610
1611     hardware_counts: { net: 32, usb: 5, hostpci: 16, audio: 1, efidisk: 1, serial: 4, rng: 1 },
1612
1613     cleanEmptyObjectKeys: function(obj) {
1614         for (const propName of Object.keys(obj)) {
1615             if (obj[propName] === null || obj[propName] === undefined) {
1616                 delete obj[propName];
1617             }
1618         }
1619     },
1620
1621     acmedomain_count: 5,
1622
1623     add_domain_to_acme: function(acme, domain) {
1624         if (acme.domains === undefined) {
1625             acme.domains = [domain];
1626         } else {
1627             acme.domains.push(domain);
1628             acme.domains = acme.domains.filter((value, index, self) => self.indexOf(value) === index);
1629         }
1630         return acme;
1631     },
1632
1633     remove_domain_from_acme: function(acme, domain) {
1634         if (acme.domains !== undefined) {
1635             acme.domains = acme
1636                 .domains
1637                 .filter((value, index, self) => self.indexOf(value) === index && value !== domain);
1638         }
1639         return acme;
1640     },
1641
1642     handleStoreErrorOrMask: function(view, store, regex, callback) {
1643         view.mon(store, 'load', function(proxy, response, success, operation) {
1644             if (success) {
1645                 Proxmox.Utils.setErrorMask(view, false);
1646                 return;
1647             }
1648             let msg;
1649             if (operation.error.statusText) {
1650                 if (operation.error.statusText.match(regex)) {
1651                     callback(view, operation.error);
1652                     return;
1653                 } else {
1654                     msg = operation.error.statusText + ' (' + operation.error.status + ')';
1655                 }
1656             } else {
1657                 msg = gettext('Connection error');
1658             }
1659             Proxmox.Utils.setErrorMask(view, msg);
1660         });
1661     },
1662
1663     showCephInstallOrMask: function(container, msg, nodename, callback) {
1664         if (msg.match(/not (installed|initialized)/i)) {
1665             if (Proxmox.UserName === 'root@pam') {
1666                 container.el.mask();
1667                 if (!container.down('pveCephInstallWindow')) {
1668                     var isInstalled = !!msg.match(/not initialized/i);
1669                     var win = Ext.create('PVE.ceph.Install', {
1670                         nodename: nodename,
1671                     });
1672                     win.getViewModel().set('isInstalled', isInstalled);
1673                     container.add(win);
1674                     win.show();
1675                     callback(win);
1676                 }
1677             } else {
1678                 container.mask(Ext.String.format(gettext('{0} not installed.') +
1679                     ' ' + gettext('Log in as root to install.'), 'Ceph'), ['pve-static-mask']);
1680             }
1681             return true;
1682         } else {
1683             return false;
1684         }
1685     },
1686
1687     monitor_ceph_installed: function(view, rstore, nodename, maskOwnerCt) {
1688         PVE.Utils.handleStoreErrorOrMask(
1689             view,
1690             rstore,
1691             /not (installed|initialized)/i,
1692             (_, error) => {
1693                 nodename = nodename || 'localhost';
1694                 let maskTarget = maskOwnerCt ? view.ownerCt : view;
1695                 rstore.stopUpdate();
1696                 PVE.Utils.showCephInstallOrMask(maskTarget, error.statusText, nodename, win => {
1697                     view.mon(win, 'cephInstallWindowClosed', () => rstore.startUpdate());
1698                 });
1699             },
1700         );
1701     },
1702
1703
1704     propertyStringSet: function(target, source, name, value) {
1705         if (source) {
1706             if (value === undefined) {
1707                 target[name] = source;
1708             } else {
1709                 target[name] = value;
1710             }
1711         } else {
1712             delete target[name];
1713         }
1714     },
1715
1716     forEachCorosyncLink: function(nodeinfo, cb) {
1717         let re = /(?:ring|link)(\d+)_addr/;
1718         Ext.iterate(nodeinfo, (prop, val) => {
1719             let match = re.exec(prop);
1720             if (match) {
1721                 cb(Number(match[1]), val);
1722             }
1723         });
1724     },
1725
1726     cpu_vendor_map: {
1727         'default': 'QEMU',
1728         'AuthenticAMD': 'AMD',
1729         'GenuineIntel': 'Intel',
1730     },
1731
1732     cpu_vendor_order: {
1733         "AMD": 1,
1734         "Intel": 2,
1735         "QEMU": 3,
1736         "Host": 4,
1737         "_default_": 5, // includes custom models
1738     },
1739
1740     verify_ip64_address_list: function(value, with_suffix) {
1741         for (let addr of value.split(/[ ,;]+/)) {
1742             if (addr === '') {
1743                 continue;
1744             }
1745
1746             if (with_suffix) {
1747                 let parts = addr.split('%');
1748                 addr = parts[0];
1749
1750                 if (parts.length > 2) {
1751                     return false;
1752                 }
1753
1754                 if (parts.length > 1 && !addr.startsWith('fe80:')) {
1755                     return false;
1756                 }
1757             }
1758
1759             if (!Proxmox.Utils.IP64_match.test(addr)) {
1760                 return false;
1761             }
1762         }
1763
1764         return true;
1765     },
1766 },
1767
1768     singleton: true,
1769     constructor: function() {
1770         var me = this;
1771         Ext.apply(me, me.utilities);
1772
1773         Proxmox.Utils.override_task_descriptions({
1774             acmedeactivate: ['ACME Account', gettext('Deactivate')],
1775             acmenewcert: ['SRV', gettext('Order Certificate')],
1776             acmerefresh: ['ACME Account', gettext('Refresh')],
1777             acmeregister: ['ACME Account', gettext('Register')],
1778             acmerenew: ['SRV', gettext('Renew Certificate')],
1779             acmerevoke: ['SRV', gettext('Revoke Certificate')],
1780             acmeupdate: ['ACME Account', gettext('Update')],
1781             'auth-realm-sync': [gettext('Realm'), gettext('Sync')],
1782             'auth-realm-sync-test': [gettext('Realm'), gettext('Sync Preview')],
1783             cephcreatemds: ['Ceph Metadata Server', gettext('Create')],
1784             cephcreatemgr: ['Ceph Manager', gettext('Create')],
1785             cephcreatemon: ['Ceph Monitor', gettext('Create')],
1786             cephcreateosd: ['Ceph OSD', gettext('Create')],
1787             cephcreatepool: ['Ceph Pool', gettext('Create')],
1788             cephdestroymds: ['Ceph Metadata Server', gettext('Destroy')],
1789             cephdestroymgr: ['Ceph Manager', gettext('Destroy')],
1790             cephdestroymon: ['Ceph Monitor', gettext('Destroy')],
1791             cephdestroyosd: ['Ceph OSD', gettext('Destroy')],
1792             cephdestroypool: ['Ceph Pool', gettext('Destroy')],
1793             cephfscreate: ['CephFS', gettext('Create')],
1794             cephsetpool: ['Ceph Pool', gettext('Edit')],
1795             cephsetflags: ['', gettext('Change global Ceph flags')],
1796             clustercreate: ['', gettext('Create Cluster')],
1797             clusterjoin: ['', gettext('Join Cluster')],
1798             dircreate: [gettext('Directory Storage'), gettext('Create')],
1799             dirremove: [gettext('Directory'), gettext('Remove')],
1800             download: [gettext('File'), gettext('Download')],
1801             hamigrate: ['HA', gettext('Migrate')],
1802             hashutdown: ['HA', gettext('Shutdown')],
1803             hastart: ['HA', gettext('Start')],
1804             hastop: ['HA', gettext('Stop')],
1805             imgcopy: ['', gettext('Copy data')],
1806             imgdel: ['', gettext('Erase data')],
1807             lvmcreate: [gettext('LVM Storage'), gettext('Create')],
1808             lvmthincreate: [gettext('LVM-Thin Storage'), gettext('Create')],
1809             migrateall: ['', gettext('Migrate all VMs and Containers')],
1810             'move_volume': ['CT', gettext('Move Volume')],
1811             'pbs-download': ['VM/CT', gettext('File Restore Download')],
1812             pull_file: ['CT', gettext('Pull file')],
1813             push_file: ['CT', gettext('Push file')],
1814             qmclone: ['VM', gettext('Clone')],
1815             qmconfig: ['VM', gettext('Configure')],
1816             qmcreate: ['VM', gettext('Create')],
1817             qmdelsnapshot: ['VM', gettext('Delete Snapshot')],
1818             qmdestroy: ['VM', gettext('Destroy')],
1819             qmigrate: ['VM', gettext('Migrate')],
1820             qmmove: ['VM', gettext('Move disk')],
1821             qmpause: ['VM', gettext('Pause')],
1822             qmreboot: ['VM', gettext('Reboot')],
1823             qmreset: ['VM', gettext('Reset')],
1824             qmrestore: ['VM', gettext('Restore')],
1825             qmresume: ['VM', gettext('Resume')],
1826             qmrollback: ['VM', gettext('Rollback')],
1827             qmshutdown: ['VM', gettext('Shutdown')],
1828             qmsnapshot: ['VM', gettext('Snapshot')],
1829             qmstart: ['VM', gettext('Start')],
1830             qmstop: ['VM', gettext('Stop')],
1831             qmsuspend: ['VM', gettext('Hibernate')],
1832             qmtemplate: ['VM', gettext('Convert to template')],
1833             spiceproxy: ['VM/CT', gettext('Console') + ' (Spice)'],
1834             spiceshell: ['', gettext('Shell') + ' (Spice)'],
1835             startall: ['', gettext('Start all VMs and Containers')],
1836             stopall: ['', gettext('Stop all VMs and Containers')],
1837             unknownimgdel: ['', gettext('Destroy image from unknown guest')],
1838             wipedisk: ['Device', gettext('Wipe Disk')],
1839             vncproxy: ['VM/CT', gettext('Console')],
1840             vncshell: ['', gettext('Shell')],
1841             vzclone: ['CT', gettext('Clone')],
1842             vzcreate: ['CT', gettext('Create')],
1843             vzdelsnapshot: ['CT', gettext('Delete Snapshot')],
1844             vzdestroy: ['CT', gettext('Destroy')],
1845             vzdump: (type, id) => id ? `VM/CT ${id} - ${gettext('Backup')}` : gettext('Backup Job'),
1846             vzmigrate: ['CT', gettext('Migrate')],
1847             vzmount: ['CT', gettext('Mount')],
1848             vzreboot: ['CT', gettext('Reboot')],
1849             vzrestore: ['CT', gettext('Restore')],
1850             vzresume: ['CT', gettext('Resume')],
1851             vzrollback: ['CT', gettext('Rollback')],
1852             vzshutdown: ['CT', gettext('Shutdown')],
1853             vzsnapshot: ['CT', gettext('Snapshot')],
1854             vzstart: ['CT', gettext('Start')],
1855             vzstop: ['CT', gettext('Stop')],
1856             vzsuspend: ['CT', gettext('Suspend')],
1857             vztemplate: ['CT', gettext('Convert to template')],
1858             vzumount: ['CT', gettext('Unmount')],
1859             zfscreate: [gettext('ZFS Storage'), gettext('Create')],
1860         });
1861     },
1862
1863 });