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         },
 737         ldap: {
 738             name: gettext('LDAP Server'),
 739             ipanel: 'pveAuthLDAPPanel',
 740             syncipanel: 'pveAuthLDAPSyncPanel',
 741             add: true,
 742         },
 743         pam: {
 744             name: 'Linux PAM',
 745             ipanel: 'pveAuthBasePanel',
 746             add: false,
 747         },
 748         pve: {
 749             name: 'Proxmox VE authentication server',
 750             ipanel: 'pveAuthBasePanel',
 751             add: false,
 752         },
 753     },
 754
 755     storageSchema: {
 756         dir: {
 757             name: Proxmox.Utils.directoryText,
 758             ipanel: 'DirInputPanel',
 759             faIcon: 'folder',
 760             backups: true,
 761         },
 762         lvm: {
 763             name: 'LVM',
 764             ipanel: 'LVMInputPanel',
 765             faIcon: 'folder',
 766             backups: false,
 767         },
 768         lvmthin: {
 769             name: 'LVM-Thin',
 770             ipanel: 'LvmThinInputPanel',
 771             faIcon: 'folder',
 772             backups: false,
 773         },
 774         nfs: {
 775             name: 'NFS',
 776             ipanel: 'NFSInputPanel',
 777             faIcon: 'building',
 778             backups: true,
 779         },
 780         cifs: {
 781             name: 'CIFS',
 782             ipanel: 'CIFSInputPanel',
 783             faIcon: 'building',
 784             backups: true,
 785         },
 786         glusterfs: {
 787             name: 'GlusterFS',
 788             ipanel: 'GlusterFsInputPanel',
 789             faIcon: 'building',
 790             backups: true,
 791         },
 792         iscsi: {
 793             name: 'iSCSI',
 794             ipanel: 'IScsiInputPanel',
 795             faIcon: 'building',
 796             backups: false,
 797         },
 798         cephfs: {
 799             name: 'CephFS',
 800             ipanel: 'CephFSInputPanel',
 801             faIcon: 'building',
 802             backups: true,
 803         },
 804         pvecephfs: {
 805             name: 'CephFS (PVE)',
 806             ipanel: 'CephFSInputPanel',
 807             hideAdd: true,
 808             faIcon: 'building',
 809             backups: true,
 810         },
 811         rbd: {
 812             name: 'RBD',
 813             ipanel: 'RBDInputPanel',
 814             faIcon: 'building',
 815             backups: false,
 816         },
 817         pveceph: {
 818             name: 'RBD (PVE)',
 819             ipanel: 'RBDInputPanel',
 820             hideAdd: true,
 821             faIcon: 'building',
 822             backups: false,
 823         },
 824         zfs: {
 825             name: 'ZFS over iSCSI',
 826             ipanel: 'ZFSInputPanel',
 827             faIcon: 'building',
 828             backups: false,
 829         },
 830         zfspool: {
 831             name: 'ZFS',
 832             ipanel: 'ZFSPoolInputPanel',
 833             faIcon: 'folder',
 834             backups: false,
 835         },
 836         pbs: {
 837             name: 'Proxmox Backup Server',
 838             ipanel: 'PBSInputPanel',
 839             faIcon: 'floppy-o',
 840             backups: true,
 841         },
 842         drbd: {
 843             name: 'DRBD',
 844             hideAdd: true,
 845             backups: false,
 846         },
 847     },
 848
 849     sdnvnetSchema: {
 850         vnet: {
 851             name: 'vnet',
 852             faIcon: 'folder',
 853         },
 854     },
 855
 856     sdnzoneSchema: {
 857         zone: {
 858              name: 'zone',
 859              hideAdd: true,
 860         },
 861         simple: {
 862             name: 'Simple',
 863             ipanel: 'SimpleInputPanel',
 864             faIcon: 'th',
 865         },
 866         vlan: {
 867             name: 'VLAN',
 868             ipanel: 'VlanInputPanel',
 869             faIcon: 'th',
 870         },
 871         qinq: {
 872             name: 'QinQ',
 873             ipanel: 'QinQInputPanel',
 874             faIcon: 'th',
 875         },
 876         vxlan: {
 877             name: 'VXLAN',
 878             ipanel: 'VxlanInputPanel',
 879             faIcon: 'th',
 880         },
 881         evpn: {
 882             name: 'EVPN',
 883             ipanel: 'EvpnInputPanel',
 884             faIcon: 'th',
 885         },
 886     },
 887
 888     sdncontrollerSchema: {
 889         controller: {
 890              name: 'controller',
 891              hideAdd: true,
 892         },
 893         evpn: {
 894             name: 'evpn',
 895             ipanel: 'EvpnInputPanel',
 896             faIcon: 'crosshairs',
 897         },
 898         bgp: {
 899             name: 'bgp',
 900             ipanel: 'BgpInputPanel',
 901             faIcon: 'crosshairs',
 902         },
 903     },
 904
 905     sdnipamSchema: {
 906         ipam: {
 907              name: 'ipam',
 908              hideAdd: true,
 909         },
 910         pve: {
 911             name: 'PVE',
 912             ipanel: 'PVEIpamInputPanel',
 913             faIcon: 'th',
 914             hideAdd: true,
 915         },
 916         netbox: {
 917             name: 'Netbox',
 918             ipanel: 'NetboxInputPanel',
 919             faIcon: 'th',
 920         },
 921         phpipam: {
 922             name: 'PhpIpam',
 923             ipanel: 'PhpIpamInputPanel',
 924             faIcon: 'th',
 925         },
 926     },
 927
 928     sdndnsSchema: {
 929         dns: {
 930              name: 'dns',
 931              hideAdd: true,
 932         },
 933         powerdns: {
 934             name: 'powerdns',
 935             ipanel: 'PowerdnsInputPanel',
 936             faIcon: 'th',
 937         },
 938     },
 939
 940     format_sdnvnet_type: function(value, md, record) {
 941         var schema = PVE.Utils.sdnvnetSchema[value];
 942         if (schema) {
 943             return schema.name;
 944         }
 945         return Proxmox.Utils.unknownText;
 946     },
 947
 948     format_sdnzone_type: function(value, md, record) {
 949         var schema = PVE.Utils.sdnzoneSchema[value];
 950         if (schema) {
 951             return schema.name;
 952         }
 953         return Proxmox.Utils.unknownText;
 954     },
 955
 956     format_sdncontroller_type: function(value, md, record) {
 957         var schema = PVE.Utils.sdncontrollerSchema[value];
 958         if (schema) {
 959             return schema.name;
 960         }
 961         return Proxmox.Utils.unknownText;
 962     },
 963
 964     format_sdnipam_type: function(value, md, record) {
 965         var schema = PVE.Utils.sdnipamSchema[value];
 966         if (schema) {
 967             return schema.name;
 968         }
 969         return Proxmox.Utils.unknownText;
 970     },
 971
 972     format_sdndns_type: function(value, md, record) {
 973         var schema = PVE.Utils.sdndnsSchema[value];
 974         if (schema) {
 975             return schema.name;
 976         }
 977         return Proxmox.Utils.unknownText;
 978     },
 979
 980     format_storage_type: function(value, md, record) {
 981         if (value === 'rbd') {
 982             value = !record || record.get('monhost') ? 'rbd' : 'pveceph';
 983         } else if (value === 'cephfs') {
 984             value = !record || record.get('monhost') ? 'cephfs' : 'pvecephfs';
 985         }
 986
 987         var schema = PVE.Utils.storageSchema[value];
 988         if (schema) {
 989             return schema.name;
 990         }
 991         return Proxmox.Utils.unknownText;
 992     },
 993
 994     format_ha: function(value) {
 995         var text = Proxmox.Utils.noneText;
 996
 997         if (value.managed) {
 998             text = value.state || Proxmox.Utils.noneText;
 999
1000             text += ', ' + Proxmox.Utils.groupText + ': ';
1001             text += value.group || Proxmox.Utils.noneText;
1002         }
1003
1004         return text;
1005     },
1006
1007     format_content_types: function(value) {
1008         return value.split(',').sort().map(function(ct) {
1009             return PVE.Utils.contentTypes[ct] || ct;
1010         }).join(', ');
1011     },
1012
1013     render_storage_content: function(value, metaData, record) {
1014         var data = record.data;
1015         if (Ext.isNumber(data.channel) &&
1016             Ext.isNumber(data.id) &&
1017             Ext.isNumber(data.lun)) {
1018             return "CH " +
1019                 Ext.String.leftPad(data.channel, 2, '0') +
1020                 " ID " + data.id + " LUN " + data.lun;
1021         }
1022         return data.volid.replace(/^.*?:(.*?\/)?/, '');
1023     },
1024
1025     render_serverity: function(value) {
1026         return PVE.Utils.log_severity_hash[value] || value;
1027     },
1028
1029     calculate_hostcpu: function(data) {
1030         if (!(data.uptime && Ext.isNumeric(data.cpu))) {
1031             return -1;
1032         }
1033
1034         if (data.type !== 'qemu' && data.type !== 'lxc') {
1035             return -1;
1036         }
1037
1038         var index = PVE.data.ResourceStore.findExact('id', 'node/' + data.node);
1039         var node = PVE.data.ResourceStore.getAt(index);
1040         if (!Ext.isDefined(node) || node === null) {
1041             return -1;
1042         }
1043         var maxcpu = node.data.maxcpu || 1;
1044
1045         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
1046             return -1;
1047         }
1048
1049         return (data.cpu/maxcpu) * data.maxcpu;
1050     },
1051
1052     render_hostcpu: function(value, metaData, record, rowIndex, colIndex, store) {
1053         if (!(record.data.uptime && Ext.isNumeric(record.data.cpu))) {
1054             return '';
1055         }
1056
1057         if (record.data.type !== 'qemu' && record.data.type !== 'lxc') {
1058             return '';
1059         }
1060
1061         var index = PVE.data.ResourceStore.findExact('id', 'node/' + record.data.node);
1062         var node = PVE.data.ResourceStore.getAt(index);
1063         if (!Ext.isDefined(node) || node === null) {
1064             return '';
1065         }
1066         var maxcpu = node.data.maxcpu || 1;
1067
1068         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
1069             return '';
1070         }
1071
1072         var per = (record.data.cpu/maxcpu) * record.data.maxcpu * 100;
1073
1074         return per.toFixed(1) + '% of ' + maxcpu.toString() + (maxcpu > 1 ? 'CPUs' : 'CPU');
1075     },
1076
1077     render_bandwidth: function(value) {
1078         if (!Ext.isNumeric(value)) {
1079             return '';
1080         }
1081
1082         return Proxmox.Utils.format_size(value) + '/s';
1083     },
1084
1085     render_timestamp_human_readable: function(value) {
1086         return Ext.Date.format(new Date(value * 1000), 'l d F Y H:i:s');
1087     },
1088
1089     calculate_mem_usage: function(data) {
1090         if (!Ext.isNumeric(data.mem) ||
1091             data.maxmem === 0 ||
1092             data.uptime < 1) {
1093             return -1;
1094         }
1095
1096         return data.mem / data.maxmem;
1097     },
1098
1099     calculate_hostmem_usage: function(data) {
1100         if (data.type !== 'qemu' && data.type !== 'lxc') {
1101             return -1;
1102         }
1103
1104         var index = PVE.data.ResourceStore.findExact('id', 'node/' + data.node);
1105         var node = PVE.data.ResourceStore.getAt(index);
1106
1107         if (!Ext.isDefined(node) || node === null) {
1108             return -1;
1109         }
1110         var maxmem = node.data.maxmem || 0;
1111
1112         if (!Ext.isNumeric(data.mem) ||
1113             maxmem === 0 ||
1114             data.uptime < 1) {
1115             return -1;
1116         }
1117
1118         return data.mem / maxmem;
1119     },
1120
1121     render_mem_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1122         if (!Ext.isNumeric(value) || value === -1) {
1123             return '';
1124         }
1125         if (value > 1) {
1126             // we got no percentage but bytes
1127             var mem = value;
1128             var maxmem = record.data.maxmem;
1129             if (!record.data.uptime ||
1130                 maxmem === 0 ||
1131                 !Ext.isNumeric(mem)) {
1132                 return '';
1133             }
1134
1135             return (mem*100/maxmem).toFixed(1) + " %";
1136         }
1137         return (value*100).toFixed(1) + " %";
1138     },
1139
1140     render_hostmem_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1141         if (!Ext.isNumeric(record.data.mem) || value === -1) {
1142             return '';
1143         }
1144
1145         if (record.data.type !== 'qemu' && record.data.type !== 'lxc') {
1146             return '';
1147         }
1148
1149         var index = PVE.data.ResourceStore.findExact('id', 'node/' + record.data.node);
1150         var node = PVE.data.ResourceStore.getAt(index);
1151         var maxmem = node.data.maxmem || 0;
1152
1153         if (record.data.mem > 1) {
1154             // we got no percentage but bytes
1155             var mem = record.data.mem;
1156             if (!record.data.uptime ||
1157                 maxmem === 0 ||
1158                 !Ext.isNumeric(mem)) {
1159                 return '';
1160             }
1161
1162             return ((mem*100)/maxmem).toFixed(1) + " %";
1163         }
1164         return (value*100).toFixed(1) + " %";
1165     },
1166
1167     render_mem_usage: function(value, metaData, record, rowIndex, colIndex, store) {
1168         var mem = value;
1169         var maxmem = record.data.maxmem;
1170
1171         if (!record.data.uptime) {
1172             return '';
1173         }
1174
1175         if (!(Ext.isNumeric(mem) && maxmem)) {
1176             return '';
1177         }
1178
1179         return Proxmox.Utils.render_size(value);
1180     },
1181
1182     calculate_disk_usage: function(data) {
1183         if (!Ext.isNumeric(data.disk) ||
1184             ((data.type === 'qemu' || data.type === 'lxc') && data.uptime === 0) ||
1185             data.maxdisk === 0
1186         ) {
1187             return -1;
1188         }
1189
1190         return data.disk / data.maxdisk;
1191     },
1192
1193     render_disk_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
1194         if (!Ext.isNumeric(value) || value === -1) {
1195             return '';
1196         }
1197
1198         return (value * 100).toFixed(1) + " %";
1199     },
1200
1201     render_disk_usage: function(value, metaData, record, rowIndex, colIndex, store) {
1202         var disk = value;
1203         var maxdisk = record.data.maxdisk;
1204         var type = record.data.type;
1205
1206         if (!Ext.isNumeric(disk) ||
1207             maxdisk === 0 ||
1208             ((type === 'qemu' || type === 'lxc') && record.data.uptime === 0)
1209         ) {
1210             return '';
1211         }
1212
1213         return Proxmox.Utils.render_size(value);
1214     },
1215
1216     get_object_icon_class: function(type, record) {
1217         var status = '';
1218         var objType = type;
1219
1220         if (type === 'type') {
1221             // for folder view
1222             objType = record.groupbyid;
1223         } else if (record.template) {
1224             // templates
1225             objType = 'template';
1226             status = type;
1227         } else {
1228             // everything else
1229             status = record.status + ' ha-' + record.hastate;
1230         }
1231
1232         if (record.lock) {
1233             status += ' locked lock-' + record.lock;
1234         }
1235
1236         var defaults = PVE.tree.ResourceTree.typeDefaults[objType];
1237         if (defaults && defaults.iconCls) {
1238             var retVal = defaults.iconCls + ' ' + status;
1239             return retVal;
1240         }
1241
1242         return '';
1243     },
1244
1245     render_resource_type: function(value, metaData, record, rowIndex, colIndex, store) {
1246         var cls = PVE.Utils.get_object_icon_class(value, record.data);
1247
1248         var fa = '<i class="fa-fw x-grid-icon-custom ' + cls + '"></i> ';
1249         return fa + value;
1250     },
1251
1252     render_support_level: function(value, metaData, record) {
1253         return PVE.Utils.support_level_hash[value] || '-';
1254     },
1255
1256     render_upid: function(value, metaData, record) {
1257         var type = record.data.type;
1258         var id = record.data.id;
1259
1260         return Proxmox.Utils.format_task_description(type, id);
1261     },
1262
1263     render_optional_url: function(value) {
1264         if (value && value.match(/^https?:\/\//)) {
1265             return '<a target="_blank" href="' + value + '">' + value + '</a>';
1266         }
1267         return value;
1268     },
1269
1270     render_san: function(value) {
1271         var names = [];
1272         if (Ext.isArray(value)) {
1273             value.forEach(function(val) {
1274                 if (!Ext.isNumber(val)) {
1275                     names.push(val);
1276                 }
1277             });
1278             return names.join('<br>');
1279         }
1280         return value;
1281     },
1282
1283     render_full_name: function(firstname, metaData, record) {
1284         var first = firstname || '';
1285         var last = record.data.lastname || '';
1286         return Ext.htmlEncode(first + " " + last);
1287     },
1288
1289     render_u2f_error: function(error) {
1290         var ErrorNames = {
1291             '1': gettext('Other Error'),
1292             '2': gettext('Bad Request'),
1293             '3': gettext('Configuration Unsupported'),
1294             '4': gettext('Device Ineligible'),
1295             '5': gettext('Timeout'),
1296         };
1297         return "U2F Error: " + ErrorNames[error] || Proxmox.Utils.unknownText;
1298     },
1299
1300     windowHostname: function() {
1301         return window.location.hostname.replace(Proxmox.Utils.IP6_bracket_match,
1302             function(m, addr, offset, original) { return addr; });
1303     },
1304
1305     openDefaultConsoleWindow: function(consoles, consoleType, vmid, nodename, vmname, cmd) {
1306         var dv = PVE.Utils.defaultViewer(consoles, consoleType);
1307         PVE.Utils.openConsoleWindow(dv, consoleType, vmid, nodename, vmname, cmd);
1308     },
1309
1310     openConsoleWindow: function(viewer, consoleType, vmid, nodename, vmname, cmd) {
1311         if (vmid === undefined && (consoleType === 'kvm' || consoleType === 'lxc')) {
1312             throw "missing vmid";
1313         }
1314         if (!nodename) {
1315             throw "no nodename specified";
1316         }
1317
1318         if (viewer === 'html5') {
1319             PVE.Utils.openVNCViewer(consoleType, vmid, nodename, vmname, cmd);
1320         } else if (viewer === 'xtermjs') {
1321             Proxmox.Utils.openXtermJsViewer(consoleType, vmid, nodename, vmname, cmd);
1322         } else if (viewer === 'vv') {
1323             let url = '/nodes/' + nodename + '/spiceshell';
1324             let params = {
1325                 proxy: PVE.Utils.windowHostname(),
1326             };
1327             if (consoleType === 'kvm') {
1328                 url = '/nodes/' + nodename + '/qemu/' + vmid.toString() + '/spiceproxy';
1329             } else if (consoleType === 'lxc') {
1330                 url = '/nodes/' + nodename + '/lxc/' + vmid.toString() + '/spiceproxy';
1331             } else if (consoleType === 'upgrade') {
1332                 params.cmd = 'upgrade';
1333             } else if (consoleType === 'cmd') {
1334                 params.cmd = cmd;
1335             } else if (consoleType !== 'shell') {
1336                 throw `unknown spice viewer type '${consoleType}'`;
1337             }
1338             PVE.Utils.openSpiceViewer(url, params);
1339         } else {
1340             throw `unknown viewer type '${viewer}'`;
1341         }
1342     },
1343
1344     defaultViewer: function(consoles, type) {
1345         var allowSpice, allowXtermjs;
1346
1347         if (consoles === true) {
1348             allowSpice = true;
1349             allowXtermjs = true;
1350         } else if (typeof consoles === 'object') {
1351             allowSpice = consoles.spice;
1352             allowXtermjs = !!consoles.xtermjs;
1353         }
1354         let dv = PVE.VersionInfo.console || (type === 'kvm' ? 'vv' : 'xtermjs');
1355         if (dv === 'vv' && !allowSpice) {
1356             dv = allowXtermjs ? 'xtermjs' : 'html5';
1357         } else if (dv === 'xtermjs' && !allowXtermjs) {
1358             dv = allowSpice ? 'vv' : 'html5';
1359         }
1360
1361         return dv;
1362     },
1363
1364     openVNCViewer: function(vmtype, vmid, nodename, vmname, cmd) {
1365         let scaling = 'off';
1366         if (Proxmox.Utils.toolkit !== 'touch') {
1367             var sp = Ext.state.Manager.getProvider();
1368             scaling = sp.get('novnc-scaling', 'off');
1369         }
1370         var url = Ext.Object.toQueryString({
1371             console: vmtype, // kvm, lxc, upgrade or shell
1372             novnc: 1,
1373             vmid: vmid,
1374             vmname: vmname,
1375             node: nodename,
1376             resize: scaling,
1377             cmd: cmd,
1378         });
1379         var nw = window.open("?" + url, '_blank', "innerWidth=745,innerheight=427");
1380         if (nw) {
1381             nw.focus();
1382         }
1383     },
1384
1385     openSpiceViewer: function(url, params) {
1386         var downloadWithName = function(uri, name) {
1387             var link = Ext.DomHelper.append(document.body, {
1388                 tag: 'a',
1389                 href: uri,
1390                 css: 'display:none;visibility:hidden;height:0px;',
1391             });
1392
1393             // Note: we need to tell Android and Chrome the correct file name extension
1394             // but we do not set 'download' tag for other environments, because
1395             // It can have strange side effects (additional user prompt on firefox)
1396             if (navigator.userAgent.match(/Android|Chrome/i)) {
1397                 link.download = name;
1398             }
1399
1400             if (link.fireEvent) {
1401                 link.fireEvent('onclick');
1402             } else {
1403                 let evt = document.createEvent("MouseEvents");
1404                 evt.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
1405                 link.dispatchEvent(evt);
1406             }
1407         };
1408
1409         Proxmox.Utils.API2Request({
1410             url: url,
1411             params: params,
1412             method: 'POST',
1413             failure: function(response, opts) {
1414                 Ext.Msg.alert('Error', response.htmlStatus);
1415             },
1416             success: function(response, opts) {
1417                 let cfg = response.result.data;
1418                 let raw = Object.entries(cfg).reduce((acc, [k, v]) => acc + `${k}=${v}\n`, "[virt-viewer]\n");
1419                 let spiceDownload = 'data:application/x-virt-viewer;charset=UTF-8,' + encodeURIComponent(raw);
1420                 downloadWithName(spiceDownload, "pve-spice.vv");
1421             },
1422         });
1423     },
1424
1425     openTreeConsole: function(tree, record, item, index, e) {
1426         e.stopEvent();
1427         let nodename = record.data.node;
1428         let vmid = record.data.vmid;
1429         let vmname = record.data.name;
1430         if (record.data.type === 'qemu' && !record.data.template) {
1431             Proxmox.Utils.API2Request({
1432                 url: `/nodes/${nodename}/qemu/${vmid}/status/current`,
1433                 failure: response => Ext.Msg.alert('Error', response.htmlStatus),
1434                 success: function(response, opts) {
1435                     let conf = response.result.data;
1436                     let consoles = {
1437                         spice: !!conf.spice,
1438                         xtermjs: !!conf.serial,
1439                     };
1440                     PVE.Utils.openDefaultConsoleWindow(consoles, 'kvm', vmid, nodename, vmname);
1441                 },
1442             });
1443         } else if (record.data.type === 'lxc' && !record.data.template) {
1444             PVE.Utils.openDefaultConsoleWindow(true, 'lxc', vmid, nodename, vmname);
1445         }
1446     },
1447
1448     // test automation helper
1449     call_menu_handler: function(menu, text) {
1450         let item = menu.query('menuitem').find(el => el.text === text);
1451         if (item && item.handler) {
1452             item.handler();
1453         }
1454     },
1455
1456     createCmdMenu: function(v, record, item, index, event) {
1457         event.stopEvent();
1458         if (!(v instanceof Ext.tree.View)) {
1459             v.select(record);
1460         }
1461         let menu;
1462         let type = record.data.type;
1463
1464         if (record.data.template) {
1465             if (type === 'qemu' || type === 'lxc') {
1466                 menu = Ext.create('PVE.menu.TemplateMenu', {
1467                     pveSelNode: record,
1468                 });
1469             }
1470         } else if (type === 'qemu' || type === 'lxc' || type === 'node') {
1471             menu = Ext.create('PVE.' + type + '.CmdMenu', {
1472                 pveSelNode: record,
1473                 nodename: record.data.node,
1474             });
1475         } else {
1476             return undefined;
1477         }
1478
1479         menu.showAt(event.getXY());
1480         return menu;
1481     },
1482
1483     // helper for deleting field which are set to there default values
1484     delete_if_default: function(values, fieldname, default_val, create) {
1485         if (values[fieldname] === '' || values[fieldname] === default_val) {
1486             if (!create) {
1487                 if (values.delete) {
1488                     if (Ext.isArray(values.delete)) {
1489                         values.delete.push(fieldname);
1490                     } else {
1491                         values.delete += ',' + fieldname;
1492                     }
1493                 } else {
1494                     values.delete = fieldname;
1495                 }
1496             }
1497
1498             delete values[fieldname];
1499         }
1500     },
1501
1502     loadSSHKeyFromFile: function(file, callback) {
1503         // ssh-keygen produces ~ 740 bytes for a 4096 bit RSA key,  current max is 16 kbit, so assume:
1504         // 740 * 8 for max. 32kbit (5920 bytes), round upwards to 8192 bytes, leaves lots of comment space
1505         PVE.Utils.loadFile(file, callback, 8192);
1506     },
1507
1508     loadFile: function(file, callback, maxSize) {
1509         maxSize = maxSize || 32 * 1024;
1510         if (file.size > maxSize) {
1511             Ext.Msg.alert(gettext('Error'), `${gettext("Invalid file size")}: ${file.size} > ${maxSize}`);
1512             return;
1513         }
1514         let reader = new FileReader();
1515         reader.onload = evt => callback(evt.target.result);
1516         reader.readAsText(file);
1517     },
1518
1519     loadTextFromFile: function(file, callback, maxBytes) {
1520         let maxSize = maxBytes || 8192;
1521         if (file.size > maxSize) {
1522             Ext.Msg.alert(gettext('Error'), gettext("Invalid file size: ") + file.size);
1523             return;
1524         }
1525         let reader = new FileReader();
1526         reader.onload = evt => callback(evt.target.result);
1527         reader.readAsText(file);
1528     },
1529
1530     diskControllerMaxIDs: {
1531         ide: 4,
1532         sata: 6,
1533         scsi: 31,
1534         virtio: 16,
1535     },
1536
1537     // types is either undefined (all busses), an array of busses, or a single bus
1538     forEachBus: function(types, func) {
1539         let busses = Object.keys(PVE.Utils.diskControllerMaxIDs);
1540
1541         if (Ext.isArray(types)) {
1542             busses = types;
1543         } else if (Ext.isDefined(types)) {
1544             busses = [types];
1545         }
1546
1547         // check if we only have valid busses
1548         for (let i = 0; i < busses.length; i++) {
1549             if (!PVE.Utils.diskControllerMaxIDs[busses[i]]) {
1550                 throw "invalid bus: '" + busses[i] + "'";
1551             }
1552         }
1553
1554         for (let i = 0; i < busses.length; i++) {
1555             let count = PVE.Utils.diskControllerMaxIDs[busses[i]];
1556             for (let j = 0; j < count; j++) {
1557                 let cont = func(busses[i], j);
1558                 if (!cont && cont !== undefined) {
1559                     return;
1560                 }
1561             }
1562         }
1563     },
1564
1565     mp_counts: {
1566         mps: 256,
1567         unused: 256,
1568     },
1569
1570     forEachMP: function(func, includeUnused) {
1571         for (let i = 0; i < PVE.Utils.mp_counts.mps; i++) {
1572             let cont = func('mp', i);
1573             if (!cont && cont !== undefined) {
1574                 return;
1575             }
1576         }
1577
1578         if (!includeUnused) {
1579             return;
1580         }
1581
1582         for (let i = 0; i < PVE.Utils.mp_counts.unused; i++) {
1583             let cont = func('unused', i);
1584             if (!cont && cont !== undefined) {
1585                 return;
1586             }
1587         }
1588     },
1589
1590     hardware_counts: { net: 32, usb: 5, hostpci: 16, audio: 1, efidisk: 1, serial: 4, rng: 1 },
1591
1592     cleanEmptyObjectKeys: function(obj) {
1593         for (const propName of Object.keys(obj)) {
1594             if (obj[propName] === null || obj[propName] === undefined) {
1595                 delete obj[propName];
1596             }
1597         }
1598     },
1599
1600     acmedomain_count: 5,
1601
1602     add_domain_to_acme: function(acme, domain) {
1603         if (acme.domains === undefined) {
1604             acme.domains = [domain];
1605         } else {
1606             acme.domains.push(domain);
1607             acme.domains = acme.domains.filter((value, index, self) => self.indexOf(value) === index);
1608         }
1609         return acme;
1610     },
1611
1612     remove_domain_from_acme: function(acme, domain) {
1613         if (acme.domains !== undefined) {
1614             acme.domains = acme
1615                 .domains
1616                 .filter((value, index, self) => self.indexOf(value) === index && value !== domain);
1617         }
1618         return acme;
1619     },
1620
1621     handleStoreErrorOrMask: function(view, store, regex, callback) {
1622         view.mon(store, 'load', function(proxy, response, success, operation) {
1623             if (success) {
1624                 Proxmox.Utils.setErrorMask(view, false);
1625                 return;
1626             }
1627             let msg;
1628             if (operation.error.statusText) {
1629                 if (operation.error.statusText.match(regex)) {
1630                     callback(view, operation.error);
1631                     return;
1632                 } else {
1633                     msg = operation.error.statusText + ' (' + operation.error.status + ')';
1634                 }
1635             } else {
1636                 msg = gettext('Connection error');
1637             }
1638             Proxmox.Utils.setErrorMask(view, msg);
1639         });
1640     },
1641
1642     showCephInstallOrMask: function(container, msg, nodename, callback) {
1643         if (msg.match(/not (installed|initialized)/i)) {
1644             if (Proxmox.UserName === 'root@pam') {
1645                 container.el.mask();
1646                 if (!container.down('pveCephInstallWindow')) {
1647                     var isInstalled = !!msg.match(/not initialized/i);
1648                     var win = Ext.create('PVE.ceph.Install', {
1649                         nodename: nodename,
1650                     });
1651                     win.getViewModel().set('isInstalled', isInstalled);
1652                     container.add(win);
1653                     win.show();
1654                     callback(win);
1655                 }
1656             } else {
1657                 container.mask(Ext.String.format(gettext('{0} not installed.') +
1658                     ' ' + gettext('Log in as root to install.'), 'Ceph'), ['pve-static-mask']);
1659             }
1660             return true;
1661         } else {
1662             return false;
1663         }
1664     },
1665
1666     monitor_ceph_installed: function(view, rstore, nodename, maskOwnerCt) {
1667         PVE.Utils.handleStoreErrorOrMask(
1668             view,
1669             rstore,
1670             /not (installed|initialized)/i,
1671             (_, error) => {
1672                 nodename = nodename || 'localhost';
1673                 let maskTarget = maskOwnerCt ? view.ownerCt : view;
1674                 rstore.stopUpdate();
1675                 PVE.Utils.showCephInstallOrMask(maskTarget, error.statusText, nodename, win => {
1676                     view.mon(win, 'cephInstallWindowClosed', () => rstore.startUpdate());
1677                 });
1678             },
1679         );
1680     },
1681
1682
1683     propertyStringSet: function(target, source, name, value) {
1684         if (source) {
1685             if (value === undefined) {
1686                 target[name] = source;
1687             } else {
1688                 target[name] = value;
1689             }
1690         } else {
1691             delete target[name];
1692         }
1693     },
1694
1695     forEachCorosyncLink: function(nodeinfo, cb) {
1696         let re = /(?:ring|link)(\d+)_addr/;
1697         Ext.iterate(nodeinfo, (prop, val) => {
1698             let match = re.exec(prop);
1699             if (match) {
1700                 cb(Number(match[1]), val);
1701             }
1702         });
1703     },
1704
1705     cpu_vendor_map: {
1706         'default': 'QEMU',
1707         'AuthenticAMD': 'AMD',
1708         'GenuineIntel': 'Intel',
1709     },
1710
1711     cpu_vendor_order: {
1712         "AMD": 1,
1713         "Intel": 2,
1714         "QEMU": 3,
1715         "Host": 4,
1716         "_default_": 5, // includes custom models
1717     },
1718
1719     verify_ip64_address_list: function(value, with_suffix) {
1720         for (let addr of value.split(/[ ,;]+/)) {
1721             if (addr === '') {
1722                 continue;
1723             }
1724
1725             if (with_suffix) {
1726                 let parts = addr.split('%');
1727                 addr = parts[0];
1728
1729                 if (parts.length > 2) {
1730                     return false;
1731                 }
1732
1733                 if (parts.length > 1 && !addr.startsWith('fe80:')) {
1734                     return false;
1735                 }
1736             }
1737
1738             if (!Proxmox.Utils.IP64_match.test(addr)) {
1739                 return false;
1740             }
1741         }
1742
1743         return true;
1744     },
1745 },
1746
1747     singleton: true,
1748     constructor: function() {
1749         var me = this;
1750         Ext.apply(me, me.utilities);
1751
1752         Proxmox.Utils.override_task_descriptions({
1753             acmedeactivate: ['ACME Account', gettext('Deactivate')],
1754             acmenewcert: ['SRV', gettext('Order Certificate')],
1755             acmerefresh: ['ACME Account', gettext('Refresh')],
1756             acmeregister: ['ACME Account', gettext('Register')],
1757             acmerenew: ['SRV', gettext('Renew Certificate')],
1758             acmerevoke: ['SRV', gettext('Revoke Certificate')],
1759             acmeupdate: ['ACME Account', gettext('Update')],
1760             'auth-realm-sync': [gettext('Realm'), gettext('Sync')],
1761             'auth-realm-sync-test': [gettext('Realm'), gettext('Sync Preview')],
1762             cephcreatemds: ['Ceph Metadata Server', gettext('Create')],
1763             cephcreatemgr: ['Ceph Manager', gettext('Create')],
1764             cephcreatemon: ['Ceph Monitor', gettext('Create')],
1765             cephcreateosd: ['Ceph OSD', gettext('Create')],
1766             cephcreatepool: ['Ceph Pool', gettext('Create')],
1767             cephdestroymds: ['Ceph Metadata Server', gettext('Destroy')],
1768             cephdestroymgr: ['Ceph Manager', gettext('Destroy')],
1769             cephdestroymon: ['Ceph Monitor', gettext('Destroy')],
1770             cephdestroyosd: ['Ceph OSD', gettext('Destroy')],
1771             cephdestroypool: ['Ceph Pool', gettext('Destroy')],
1772             cephfscreate: ['CephFS', gettext('Create')],
1773             cephsetpool: ['Ceph Pool', gettext('Edit')],
1774             cephsetflags: ['', gettext('Change global Ceph flags')],
1775             clustercreate: ['', gettext('Create Cluster')],
1776             clusterjoin: ['', gettext('Join Cluster')],
1777             dircreate: [gettext('Directory Storage'), gettext('Create')],
1778             dirremove: [gettext('Directory'), gettext('Remove')],
1779             download: ['', gettext('Download')],
1780             hamigrate: ['HA', gettext('Migrate')],
1781             hashutdown: ['HA', gettext('Shutdown')],
1782             hastart: ['HA', gettext('Start')],
1783             hastop: ['HA', gettext('Stop')],
1784             imgcopy: ['', gettext('Copy data')],
1785             imgdel: ['', gettext('Erase data')],
1786             lvmcreate: [gettext('LVM Storage'), gettext('Create')],
1787             lvmthincreate: [gettext('LVM-Thin Storage'), gettext('Create')],
1788             migrateall: ['', gettext('Migrate all VMs and Containers')],
1789             'move_volume': ['CT', gettext('Move Volume')],
1790             'pbs-download': ['VM/CT', gettext('File Restore Download')],
1791             pull_file: ['CT', gettext('Pull file')],
1792             push_file: ['CT', gettext('Push file')],
1793             qmclone: ['VM', gettext('Clone')],
1794             qmconfig: ['VM', gettext('Configure')],
1795             qmcreate: ['VM', gettext('Create')],
1796             qmdelsnapshot: ['VM', gettext('Delete Snapshot')],
1797             qmdestroy: ['VM', gettext('Destroy')],
1798             qmigrate: ['VM', gettext('Migrate')],
1799             qmmove: ['VM', gettext('Move disk')],
1800             qmpause: ['VM', gettext('Pause')],
1801             qmreboot: ['VM', gettext('Reboot')],
1802             qmreset: ['VM', gettext('Reset')],
1803             qmrestore: ['VM', gettext('Restore')],
1804             qmresume: ['VM', gettext('Resume')],
1805             qmrollback: ['VM', gettext('Rollback')],
1806             qmshutdown: ['VM', gettext('Shutdown')],
1807             qmsnapshot: ['VM', gettext('Snapshot')],
1808             qmstart: ['VM', gettext('Start')],
1809             qmstop: ['VM', gettext('Stop')],
1810             qmsuspend: ['VM', gettext('Hibernate')],
1811             qmtemplate: ['VM', gettext('Convert to template')],
1812             spiceproxy: ['VM/CT', gettext('Console') + ' (Spice)'],
1813             spiceshell: ['', gettext('Shell') + ' (Spice)'],
1814             startall: ['', gettext('Start all VMs and Containers')],
1815             stopall: ['', gettext('Stop all VMs and Containers')],
1816             unknownimgdel: ['', gettext('Destroy image from unknown guest')],
1817             wipedisk: ['Device', gettext('Wipe Disk')],
1818             vncproxy: ['VM/CT', gettext('Console')],
1819             vncshell: ['', gettext('Shell')],
1820             vzclone: ['CT', gettext('Clone')],
1821             vzcreate: ['CT', gettext('Create')],
1822             vzdelsnapshot: ['CT', gettext('Delete Snapshot')],
1823             vzdestroy: ['CT', gettext('Destroy')],
1824             vzdump: (type, id) => id ? `VM/CT ${id} - ${gettext('Backup')}` : gettext('Backup Job'),
1825             vzmigrate: ['CT', gettext('Migrate')],
1826             vzmount: ['CT', gettext('Mount')],
1827             vzreboot: ['CT', gettext('Reboot')],
1828             vzrestore: ['CT', gettext('Restore')],
1829             vzresume: ['CT', gettext('Resume')],
1830             vzrollback: ['CT', gettext('Rollback')],
1831             vzshutdown: ['CT', gettext('Shutdown')],
1832             vzsnapshot: ['CT', gettext('Snapshot')],
1833             vzstart: ['CT', gettext('Start')],
1834             vzstop: ['CT', gettext('Stop')],
1835             vzsuspend: ['CT', gettext('Suspend')],
1836             vztemplate: ['CT', gettext('Convert to template')],
1837             vzumount: ['CT', gettext('Unmount')],
1838             zfscreate: [gettext('ZFS Storage'), gettext('Create')],
1839         });
1840     },
1841
1842 });