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