www/manager6/Utils.js

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