www/manager6/window/GuestImport.js

   1 Ext.define('PVE.window.GuestImport', {
   2     extend: 'Proxmox.window.Edit', // fixme: Proxmox.window.Edit?
   3     alias: 'widget.pveGuestImportWindow',
   4
   5     title: gettext('Import Guest'),
   6
   7     submitUrl: function() {
   8         let me = this;
   9         return `/nodes/${me.nodename}/qemu`;
  10     },
  11
  12     isAdd: true,
  13     isCreate: true,
  14     submitText: gettext('Import'),
  15     showTaskViewer: true,
  16     method: 'POST',
  17
  18     loadUrl: function(_url, { storage, nodename, volumeName }) {
  19         let args = Ext.Object.toQueryString({ volume: volumeName });
  20         return `/nodes/${nodename}/storage/${storage}/import-metadata?${args}`;
  21     },
  22
  23     controller: {
  24         xclass: 'Ext.app.ViewController',
  25
  26         setNodename: function(_column, widget) {
  27             let me = this;
  28             let view = me.getView();
  29             widget.setNodename(view.nodename);
  30         },
  31
  32         diskStorageChange: function(storageSelector, value) {
  33             let me = this;
  34
  35             let grid = me.lookup('diskGrid');
  36             let rec = storageSelector.getWidgetRecord();
  37             let validFormats = storageSelector.store.getById(value)?.data.format;
  38             grid.query('pveDiskFormatSelector').some((selector) => {
  39                 if (selector.getWidgetRecord().data.id !== rec.data.id) {
  40                     return false;
  41                 }
  42
  43                 if (validFormats?.[0]?.qcow2) {
  44                     selector.setDisabled(false);
  45                     selector.setValue('qcow2');
  46                 } else {
  47                     selector.setValue('raw');
  48                     selector.setDisabled(true);
  49                 }
  50
  51                 return true;
  52             });
  53         },
  54
  55         isoStorageChange: function(storageSelector, value) {
  56             let me = this;
  57
  58             let grid = me.lookup('cdGrid');
  59             let rec = storageSelector.getWidgetRecord();
  60             grid.query('pveFileSelector').some((selector) => {
  61                 if (selector.getWidgetRecord().data.id !== rec.data.id) {
  62                     return false;
  63                 }
  64
  65                 selector.setStorage(value);
  66                 if (!value) {
  67                     selector.setValue('');
  68                 }
  69
  70                 return true;
  71             });
  72         },
  73
  74         onOSBaseChange: function(_field, value) {
  75             let me = this;
  76             let ostype = me.lookup('ostype');
  77             let store = ostype.getStore();
  78             store.setData(PVE.Utils.kvm_ostypes[value]);
  79             let old_val = ostype.getValue();
  80             if (old_val && store.find('val', old_val) !== -1) {
  81                 ostype.setValue(old_val);
  82             } else {
  83                 ostype.setValue(store.getAt(0));
  84             }
  85         },
  86
  87         calculateConfig: function() {
  88             let me = this;
  89             let inputPanel = me.lookup('mainInputPanel');
  90             let summaryGrid = me.lookup('summaryGrid');
  91             let values = inputPanel.getValues();
  92             summaryGrid.getStore().setData(Object.entries(values).map(([key, value]) => ({ key, value })));
  93         },
  94
  95         calculateAdditionalCDIdx: function() {
  96             let me = this;
  97
  98             let maxIde = me.getMaxControllerId('ide');
  99             let maxSata = me.getMaxControllerId('sata');
 100             // only ide0 and ide2 can be used reliably for isos (e.g. for q35)
 101             if (maxIde < 0) {
 102                 return 'ide0';
 103             }
 104             if (maxIde < 2) {
 105                 return 'ide2';
 106             }
 107             if (maxSata < PVE.Utils.diskControllerMaxIDs.sata - 1) {
 108                 return `sata${maxSata+1}`;
 109             }
 110
 111             return '';
 112         },
 113
 114         // assume assigned sata disks indices are continuous, so without holes
 115         getMaxControllerId: function(controller) {
 116             let me = this;
 117             let view = me.getView();
 118             if (!controller) {
 119                 return -1;
 120             }
 121
 122             let max = view[`max${controller}`];
 123             if (max !== undefined) {
 124                 return max;
 125             }
 126
 127             max = -1;
 128             for (const key of Object.keys(me.getView().vmConfig)) {
 129                 if (!key.toLowerCase().startsWith(controller)) {
 130                     continue;
 131                 }
 132                 let idx = parseInt(key.slice(controller.length), 10);
 133                 if (idx > max) {
 134                     max = idx;
 135                 }
 136             }
 137             me.lookup('diskGrid').getStore().each(rec => {
 138                 if (!rec.data.id.toLowerCase().startsWith(controller)) {
 139                     return;
 140                 }
 141                 let idx = parseInt(rec.data.id.slice(controller.length), 10);
 142                 if (idx > max) {
 143                     max = idx;
 144                 }
 145             });
 146             me.lookup('cdGrid').getStore().each(rec => {
 147                 if (!rec.data.id.toLowerCase().startsWith(controller) || rec.data.hidden) {
 148                     return;
 149                 }
 150                 let idx = parseInt(rec.data.id.slice(controller.length), 10);
 151                 if (idx > max) {
 152                     max = idx;
 153                 }
 154             });
 155
 156             view[`max${controller}`] = max;
 157             return max;
 158         },
 159
 160         mapDisk: function(value, metaData) {
 161             let me = this;
 162             let mapSata = me.lookup('mapSata');
 163             if (mapSata.isDisabled() || !mapSata.getValue()) {
 164                 return value;
 165             }
 166             if (!value.toLowerCase().startsWith('scsi')) {
 167                 return value;
 168             }
 169             let offset = parseInt(value.slice(4), 10);
 170             let newIdx = offset + me.getMaxControllerId('sata') + 1;
 171             if (me.getViewModel().get('isWindows') && me.getView().additionalCdIdx?.startsWith('sata')) {
 172                 // additionalCdIdx takes the highest sata port
 173                 newIdx++;
 174             }
 175             if (newIdx >= PVE.Utils.diskControllerMaxIDs.sata) {
 176                 let prefix = '';
 177                 if (metaData !== undefined) {
 178                     // we're in the renderer so put a warning here
 179                     let warning = gettext('Too many disks, could not map to SATA.');
 180                     prefix = `<i data-qtip="${warning}" class="fa fa-exclamation-triangle warning"></i> `;
 181                 }
 182                 return `${prefix}${value}`;
 183             }
 184             return `sata${newIdx}`;
 185         },
 186
 187         refreshGrids: function() {
 188             this.lookup('diskGrid').reconfigure();
 189             this.lookup('cdGrid').reconfigure();
 190             this.lookup('netGrid').reconfigure();
 191         },
 192
 193         onOSTypeChange: function(_cb, value) {
 194             let me = this;
 195             if (!value) {
 196                 return;
 197             }
 198             let store = me.lookup('cdGrid').getStore();
 199             let collection = store.getData().getSource() ?? store.getData();
 200             let rec = collection.find('autogenerated', true);
 201
 202             let isWindows = (value ?? '').startsWith('w');
 203             if (rec) {
 204                 rec.set('hidden', !isWindows);
 205                 rec.commit();
 206             }
 207             let prepareVirtio = me.lookup('mapSata').getValue();
 208             let defaultScsiHw = me.getView().vmConfig.scsihw ?? '__default__';
 209             me.lookup('scsihw').setValue(prepareVirtio && isWindows ? 'virtio-scsi-single' : defaultScsiHw);
 210
 211             me.refreshGrids();
 212         },
 213
 214         onPrepareVirtioChange: function(_cb, value) {
 215             let me = this;
 216
 217             let scsihw = me.lookup('scsihw');
 218             scsihw.suspendEvents();
 219             scsihw.setValue(value ? 'virtio-scsi-single' : me.getView().vmConfig.scsihw);
 220             scsihw.resumeEvents();
 221
 222             me.refreshGrids();
 223         },
 224
 225         onScsiHwChange: function(_field, value) {
 226             let me = this;
 227             me.getView().vmConfig.scsihw = value;
 228         },
 229
 230         onUniqueMACChange: function(_cb, value) {
 231             let me = this;
 232
 233             me.getViewModel().set('uniqueMACAdresses', value);
 234
 235             me.lookup('netGrid').reconfigure();
 236         },
 237
 238         renderMacAddress: function(value, metaData, record, rowIndex, colIndex, store, view) {
 239             let me = this;
 240             let vm = me.getViewModel();
 241
 242             return !vm.get('uniqueMACAdresses') && value ? value : 'auto';
 243         },
 244
 245         control: {
 246             'grid field': {
 247                 // update records from widgetcolumns
 248                 change: function(widget, value) {
 249                     let rec = widget.getWidgetRecord();
 250                     rec.set(widget.name, value);
 251                     rec.commit();
 252                 },
 253             },
 254             'grid[reference=diskGrid] pveStorageSelector': {
 255                 change: 'diskStorageChange',
 256             },
 257             'grid[reference=cdGrid] pveStorageSelector': {
 258                 change: 'isoStorageChange',
 259             },
 260             'field[name=osbase]': {
 261                 change: 'onOSBaseChange',
 262             },
 263             'panel[reference=summaryTab]': {
 264                 activate: 'calculateConfig',
 265             },
 266             'proxmoxcheckbox[reference=mapSata]': {
 267                 change: 'onPrepareVirtioChange',
 268             },
 269             'combobox[name=ostype]': {
 270                 change: 'onOSTypeChange',
 271             },
 272             'pveScsiHwSelector': {
 273                 change: 'onScsiHwChange',
 274             },
 275             'proxmoxcheckbox[name=uniqueMACs]': {
 276                 change: 'onUniqueMACChange',
 277             },
 278         },
 279     },
 280
 281     viewModel: {
 282         data: {
 283             coreCount: 1,
 284             socketCount: 1,
 285             liveImport: false,
 286             os: 'l26',
 287             maxCdDrives: false,
 288             uniqueMACAdresses: false,
 289             warnings: [],
 290         },
 291
 292         formulas: {
 293             totalCoreCount: get => get('socketCount') * get('coreCount'),
 294             hideWarnings: get => get('warnings').length === 0,
 295             warningsText: get => '<ul style="margin: 0; padding-left: 20px;">'
 296                 + get('warnings').map(w => `<li>${w}</li>`).join('') + '</ul>',
 297             liveImportNote: get => !get('liveImport') ? ''
 298                 : gettext('Note: If anything goes wrong during the live-import, new data written by the VM may be lost.'),
 299             isWindows: get => (get('os') ?? '').startsWith('w'),
 300         },
 301     },
 302
 303     width: 700,
 304     bodyPadding: 0,
 305
 306     items: [
 307         {
 308             xtype: 'tabpanel',
 309             defaults: {
 310                 bodyPadding: 10,
 311             },
 312             items: [
 313                 {
 314                     title: gettext('General'),
 315                     xtype: 'inputpanel',
 316                     reference: 'mainInputPanel',
 317                     onGetValues: function(values) {
 318                         let me = this;
 319                         let grid = me.up('pveGuestImportWindow');
 320                         let vm = grid.getViewModel();
 321
 322                         // from pveDiskStorageSelector
 323                         let defaultStorage = values.hdstorage;
 324                         let defaultFormat = values.diskformat;
 325                         delete values.hdstorage;
 326                         delete values.diskformat;
 327
 328                         let defaultBridge = values.defaultBridge;
 329                         delete values.defaultBridge;
 330
 331                         let config = Ext.apply(grid.vmConfig, values);
 332
 333                         if (config.scsi0) {
 334                             config.scsi0 = config.scsi0.replace('local:0,', 'local:0,format=qcow2,');
 335                         }
 336
 337                         let parsedBoot = PVE.Parser.parsePropertyString(config.boot ?? '');
 338                         if (parsedBoot.order) {
 339                             parsedBoot.order = parsedBoot.order.split(';');
 340                         }
 341
 342                         grid.lookup('diskGrid').getStore().each((rec) => {
 343                             if (!rec.data.enable) {
 344                                 return;
 345                             }
 346                             let id = grid.getController().mapDisk(rec.data.id);
 347                             if (id !== rec.data.id && parsedBoot?.order) {
 348                                 let idx = parsedBoot.order.indexOf(rec.data.id);
 349                                 if (idx !== -1) {
 350                                     parsedBoot.order[idx] = id;
 351                                 }
 352                             }
 353                             let data = {
 354                                 ...rec.data,
 355                             };
 356                             delete data.enable;
 357                             delete data.id;
 358                             delete data.size;
 359                             if (!data.file) {
 360                                 data.file = defaultStorage;
 361                                 data.format = defaultFormat;
 362                             }
 363                             data.file += ':0'; // for our special api format
 364                             if (id === 'efidisk0') {
 365                                 delete data['import-from'];
 366                             }
 367                             config[id] = PVE.Parser.printQemuDrive(data);
 368                         });
 369
 370                         if (parsedBoot.order) {
 371                             parsedBoot.order = parsedBoot.order.join(';');
 372                         }
 373                         config.boot = PVE.Parser.printPropertyString(parsedBoot);
 374
 375                         grid.lookup('netGrid').getStore().each((rec) => {
 376                             if (!rec.data.enable) {
 377                                 return;
 378                             }
 379                             let id = rec.data.id;
 380                             let data = {
 381                                 ...rec.data,
 382                             };
 383                             delete data.enable;
 384                             delete data.id;
 385                             if (!data.bridge) {
 386                                 data.bridge = defaultBridge;
 387                             }
 388                             if (vm.get('uniqueMACAdresses')) {
 389                                 data.macaddr = undefined;
 390                             }
 391                             config[id] = PVE.Parser.printQemuNetwork(data);
 392                         });
 393
 394                         grid.lookup('cdGrid').getStore().each((rec) => {
 395                             if (!rec.data.enable) {
 396                                 return;
 397                             }
 398                             let id = rec.data.id;
 399                             let cd = {
 400                                 media: 'cdrom',
 401                                 file: rec.data.file ? rec.data.file : 'none',
 402                             };
 403                             config[id] = PVE.Parser.printPropertyString(cd);
 404                         });
 405
 406                         config.scsihw = grid.lookup('scsihw').getValue();
 407
 408                         if (grid.lookup('liveimport').getValue()) {
 409                             config['live-restore'] = 1;
 410                         }
 411
 412                         // remove __default__ values
 413                         for (const [key, value] of Object.entries(config)) {
 414                             if (value === '__default__') {
 415                                 delete config[key];
 416                             }
 417                         }
 418
 419                         return config;
 420                     },
 421
 422                     column1: [
 423                         {
 424                             xtype: 'pveGuestIDSelector',
 425                             name: 'vmid',
 426                             fieldLabel: 'VM',
 427                             guestType: 'qemu',
 428                             loadNextFreeID: true,
 429                         },
 430                         {
 431                             xtype: 'proxmoxintegerfield',
 432                             fieldLabel: gettext('Sockets'),
 433                             name: 'sockets',
 434                             reference: 'socketsField',
 435                             value: 1,
 436                             minValue: 1,
 437                             maxValue: 128,
 438                             allowBlank: true,
 439                             bind: {
 440                                 value: '{socketCount}',
 441                             },
 442                         },
 443                         {
 444                             xtype: 'proxmoxintegerfield',
 445                             fieldLabel: gettext('Cores'),
 446                             name: 'cores',
 447                             reference: 'coresField',
 448                             value: 1,
 449                             minValue: 1,
 450                             maxValue: 1024,
 451                             allowBlank: true,
 452                             bind: {
 453                                 value: '{coreCount}',
 454                             },
 455                         },
 456                         {
 457                             xtype: 'pveMemoryField',
 458                             fieldLabel: gettext('Memory') + ' (MiB)',
 459                             name: 'memory',
 460                             reference: 'memoryField',
 461                             value: 512,
 462                             allowBlank: true,
 463                         },
 464                         { xtype: 'displayfield' }, // spacer
 465                         { xtype: 'displayfield' }, // spacer
 466                         {
 467                             xtype: 'pveDiskStorageSelector',
 468                             reference: 'defaultStorage',
 469                             storageLabel: gettext('Default Storage'),
 470                             storageContent: 'images',
 471                             autoSelect: true,
 472                             hideSize: true,
 473                             name: 'defaultStorage',
 474                         },
 475                     ],
 476
 477                     column2: [
 478                         {
 479                             xtype: 'textfield',
 480                             fieldLabel: gettext('Name'),
 481                             name: 'name',
 482                             vtype: 'DnsName',
 483                             reference: 'nameField',
 484                             allowBlank: true,
 485                         },
 486                         {
 487                             xtype: 'CPUModelSelector',
 488                             name: 'cpu',
 489                             reference: 'cputype',
 490                             value: 'x86-64-v2-AES',
 491                             fieldLabel: gettext('CPU Type'),
 492                         },
 493                         {
 494                             xtype: 'displayfield',
 495                             fieldLabel: gettext('Total cores'),
 496                             name: 'totalcores',
 497                             isFormField: false,
 498                             bind: {
 499                                 value: '{totalCoreCount}',
 500                             },
 501                         },
 502                         {
 503                             xtype: 'combobox',
 504                             submitValue: false,
 505                             name: 'osbase',
 506                             fieldLabel: gettext('OS Type'),
 507                             editable: false,
 508                             queryMode: 'local',
 509                             value: 'Linux',
 510                             store: Object.keys(PVE.Utils.kvm_ostypes),
 511                         },
 512                         {
 513                             xtype: 'combobox',
 514                             name: 'ostype',
 515                             reference: 'ostype',
 516                             fieldLabel: gettext('Version'),
 517                             value: 'l26',
 518                             allowBlank: false,
 519                             editable: false,
 520                             queryMode: 'local',
 521                             valueField: 'val',
 522                             displayField: 'desc',
 523                             bind: {
 524                                 value: '{os}',
 525                             },
 526                             store: {
 527                                 fields: ['desc', 'val'],
 528                                 data: PVE.Utils.kvm_ostypes.Linux,
 529                             },
 530                         },
 531                         { xtype: 'displayfield' }, // spacer
 532                         {
 533                             xtype: 'PVE.form.BridgeSelector',
 534                             reference: 'defaultBridge',
 535                             name: 'defaultBridge',
 536                             allowBlank: false,
 537                             fieldLabel: gettext('Default Bridge'),
 538                         },
 539                     ],
 540
 541                     columnB: [
 542                         {
 543                             xtype: 'proxmoxcheckbox',
 544                             fieldLabel: gettext('Live Import'),
 545                             reference: 'liveimport',
 546                             isFormField: false,
 547                             boxLabelCls: 'pmx-hint black x-form-cb-label',
 548                             bind: {
 549                                 value: '{liveImport}',
 550                                 boxLabel: '{liveImportNote}',
 551                             },
 552                         },
 553                         {
 554                             xtype: 'displayfield',
 555                             fieldLabel: gettext('Warnings'),
 556                             labelWidth: 200,
 557                             hidden: true,
 558                             bind: {
 559                                 hidden: '{hideWarnings}',
 560                             },
 561                         },
 562                         {
 563                             xtype: 'displayfield',
 564                             reference: 'warningText',
 565                             userCls: 'pmx-hint',
 566                             hidden: true,
 567                             bind: {
 568                                 hidden: '{hideWarnings}',
 569                                 value: '{warningsText}',
 570                             },
 571                         },
 572                     ],
 573                 },
 574                 {
 575                     title: gettext('Advanced'),
 576                     xtype: 'inputpanel',
 577
 578                     // the first inputpanel handles all values, so prevent value leakage here
 579                     onGetValues: () => ({}),
 580
 581                     columnT: [
 582                         {
 583                             xtype: 'displayfield',
 584                             fieldLabel: gettext('Disks'),
 585                             labelWidth: 200,
 586                         },
 587                         {
 588                             xtype: 'grid',
 589                             reference: 'diskGrid',
 590                             minHeight: 60,
 591                             maxHeight: 150,
 592                             store: {
 593                                 data: [],
 594                                 sorters: [
 595                                     'id',
 596                                 ],
 597                             },
 598                             columns: [
 599                                 {
 600                                     xtype: 'checkcolumn',
 601                                     header: gettext('Use'),
 602                                     width: 50,
 603                                     dataIndex: 'enable',
 604                                     listeners: {
 605                                         checkchange: function(_column, _rowIndex, _checked, record) {
 606                                             record.commit();
 607                                         },
 608                                     },
 609                                 },
 610                                 {
 611                                     text: gettext('Disk'),
 612                                     dataIndex: 'id',
 613                                     renderer: 'mapDisk',
 614                                 },
 615                                 {
 616                                     text: gettext('Source'),
 617                                     dataIndex: 'import-from',
 618                                     flex: 1,
 619                                     renderer: function(value) {
 620                                         return value.replace(/^.*\//, '');
 621                                     },
 622                                 },
 623                                 {
 624                                     text: gettext('Size'),
 625                                     dataIndex: 'size',
 626                                     renderer: (value) => {
 627                                         if (Ext.isNumeric(value)) {
 628                                             return Proxmox.Utils.render_size(value);
 629                                         }
 630                                         return value ?? Proxmox.Utils.unknownText;
 631                                     },
 632                                 },
 633                                 {
 634                                     text: gettext('Storage'),
 635                                     dataIndex: 'file',
 636                                     xtype: 'widgetcolumn',
 637                                     width: 150,
 638                                     widget: {
 639                                         xtype: 'pveStorageSelector',
 640                                         isFormField: false,
 641                                         autoSelect: false,
 642                                         allowBlank: true,
 643                                         emptyText: gettext('From Default'),
 644                                         name: 'file',
 645                                         storageContent: 'images',
 646                                     },
 647                                     onWidgetAttach: 'setNodename',
 648                                 },
 649                                 {
 650                                     text: gettext('Format'),
 651                                     dataIndex: 'format',
 652                                     xtype: 'widgetcolumn',
 653                                     width: 150,
 654                                     widget: {
 655                                         xtype: 'pveDiskFormatSelector',
 656                                         name: 'format',
 657                                         disabled: true,
 658                                         isFormField: false,
 659                                         matchFieldWidth: false,
 660                                     },
 661                                 },
 662                             ],
 663                         },
 664                     ],
 665
 666                     column1: [
 667                         {
 668                             xtype: 'proxmoxcheckbox',
 669                             fieldLabel: gettext('Prepare for VirtIO-SCSI'),
 670                             labelWidth: 200,
 671                             reference: 'mapSata',
 672                             name: 'mapSata',
 673                             submitValue: false,
 674                             disabled: true,
 675                             bind: {
 676                                 disabled: '{!isWindows}',
 677                             },
 678                             autoEl: {
 679                                 tag: 'div',
 680                                 'data-qtip': gettext('Maps SCSI disks to SATA and changes the SCSI Controller. Useful for a quicker switch to VirtIO-SCSI attached disks'),
 681                             },
 682                         },
 683                     ],
 684
 685                     column2: [
 686                         {
 687                             xtype: 'pveScsiHwSelector',
 688                             reference: 'scsihw',
 689                             name: 'scsihw',
 690                             value: '__default__',
 691                             submitValue: false,
 692                             fieldLabel: gettext('SCSI Controller'),
 693                         },
 694                     ],
 695
 696                     columnB: [
 697                         {
 698                             xtype: 'displayfield',
 699                             fieldLabel: gettext('CD/DVD Drives'),
 700                             labelWidth: 200,
 701                         },
 702                         {
 703                             xtype: 'grid',
 704                             reference: 'cdGrid',
 705                             minHeight: 60,
 706                             maxHeight: 150,
 707                             store: {
 708                                 data: [],
 709                                 sorters: [
 710                                     'id',
 711                                 ],
 712                                 filters: [
 713                                     function(rec) {
 714                                         return !rec.data.hidden;
 715                                     },
 716                                 ],
 717                             },
 718                             columns: [
 719                                 {
 720                                     xtype: 'checkcolumn',
 721                                     header: gettext('Use'),
 722                                     width: 50,
 723                                     dataIndex: 'enable',
 724                                     listeners: {
 725                                         checkchange: function(_column, _rowIndex, _checked, record) {
 726                                             record.commit();
 727                                         },
 728                                     },
 729                                 },
 730                                 {
 731                                     text: gettext('Slot'),
 732                                     dataIndex: 'id',
 733                                     sorted: true,
 734                                 },
 735                                 {
 736                                     text: gettext('Storage'),
 737                                     xtype: 'widgetcolumn',
 738                                     width: 150,
 739                                     widget: {
 740                                         xtype: 'pveStorageSelector',
 741                                         isFormField: false,
 742                                         autoSelect: false,
 743                                         allowBlank: true,
 744                                         emptyText: Proxmox.Utils.noneText,
 745                                         storageContent: 'iso',
 746                                     },
 747                                     onWidgetAttach: 'setNodename',
 748                                 },
 749                                 {
 750                                     text: gettext('ISO'),
 751                                     dataIndex: 'file',
 752                                     xtype: 'widgetcolumn',
 753                                     flex: 1,
 754                                     widget: {
 755                                         xtype: 'pveFileSelector',
 756                                         name: 'file',
 757                                         isFormField: false,
 758                                         allowBlank: true,
 759                                         emptyText: Proxmox.Utils.noneText,
 760                                         storageContent: 'iso',
 761                                     },
 762                                     onWidgetAttach: 'setNodename',
 763                                 },
 764                             ],
 765                         },
 766                         {
 767                             xtype: 'displayfield',
 768                             fieldLabel: gettext('Network Interfaces'),
 769                             labelWidth: 200,
 770                             style: {
 771                                 paddingTop: '10px',
 772                             },
 773                         },
 774                         {
 775                             xtype: 'grid',
 776                             minHeight: 58,
 777                             maxHeight: 150,
 778                             reference: 'netGrid',
 779                             store: {
 780                                 data: [],
 781                                 sorters: [
 782                                     'id',
 783                                 ],
 784                             },
 785                             columns: [
 786                                 {
 787                                     xtype: 'checkcolumn',
 788                                     header: gettext('Use'),
 789                                     width: 50,
 790                                     dataIndex: 'enable',
 791                                     listeners: {
 792                                         checkchange: function(_column, _rowIndex, _checked, record) {
 793                                             record.commit();
 794                                         },
 795                                     },
 796                                 },
 797                                 {
 798                                     text: gettext('ID'),
 799                                     dataIndex: 'id',
 800                                 },
 801                                 {
 802                                     text: gettext('MAC address'),
 803                                     flex: 1,
 804                                     dataIndex: 'macaddr',
 805                                     renderer: 'renderMacAddress',
 806                                 },
 807                                 {
 808                                     text: gettext('Model'),
 809                                     flex: 1,
 810                                     dataIndex: 'model',
 811                                     xtype: 'widgetcolumn',
 812                                     widget: {
 813                                         xtype: 'pveNetworkCardSelector',
 814                                         name: 'model',
 815                                         isFormField: false,
 816                                         allowBlank: false,
 817                                     },
 818                                 },
 819                                 {
 820                                     text: gettext('Bridge'),
 821                                     dataIndex: 'bridge',
 822                                     xtype: 'widgetcolumn',
 823                                     flex: 1,
 824                                     widget: {
 825                                         xtype: 'PVE.form.BridgeSelector',
 826                                         name: 'bridge',
 827                                         isFormField: false,
 828                                         autoSelect: false,
 829                                         allowBlank: true,
 830                                         emptyText: gettext('From Default'),
 831                                     },
 832                                     onWidgetAttach: 'setNodename',
 833                                 },
 834                             ],
 835                         },
 836                         {
 837                             xtype: 'proxmoxcheckbox',
 838                             name: 'uniqueMACs',
 839                             boxLabel: gettext('Unique MAC addresses'),
 840                             uncheckedValue: false,
 841                             value: false,
 842                         },
 843                     ],
 844                 },
 845                 {
 846                     title: gettext('Resulting Config'),
 847                     reference: 'summaryTab',
 848                     items: [
 849                         {
 850                             xtype: 'grid',
 851                             reference: 'summaryGrid',
 852                             maxHeight: 400,
 853                             scrollable: true,
 854                             store: {
 855                                 model: 'KeyValue',
 856                                 sorters: [{
 857                                     property: 'key',
 858                                     direction: 'ASC',
 859                                 }],
 860                             },
 861                             columns: [
 862                                 { header: 'Key', width: 150, dataIndex: 'key' },
 863                                 { header: 'Value', flex: 1, dataIndex: 'value' },
 864                             ],
 865                         },
 866                     ],
 867                 },
 868             ],
 869         },
 870     ],
 871
 872     initComponent: function() {
 873         let me = this;
 874
 875         if (!me.volumeName) {
 876             throw "no volumeName given";
 877         }
 878
 879         if (!me.storage) {
 880             throw "no storage given";
 881         }
 882
 883         if (!me.nodename) {
 884             throw "no nodename given";
 885         }
 886
 887         me.callParent();
 888
 889         me.setTitle(Ext.String.format(gettext('Import Guest - {0}'), `${me.storage}:${me.volumeName}`));
 890
 891         me.lookup('defaultStorage').setNodename(me.nodename);
 892         me.lookup('defaultBridge').setNodename(me.nodename);
 893
 894         let renderWarning = w => {
 895             const warningsCatalogue = {
 896                 'cdrom-image-ignored': gettext("CD-ROM images cannot get imported, if required you can reconfigure the '{0}' drive in the 'Advanced' tab."),
 897                 'nvme-unsupported': gettext("NVMe disks are currently not supported, '{0}' will get attaced as SCSI"),
 898                 'ovmf-with-lsi-unsupported': gettext("OVMF is built without LSI drivers, scsi hardware was set to '{1}'"),
 899                 'serial-port-socket-only': gettext("Serial socket '{0}' will be mapped to a socket"),
 900                 'guest-is-running': gettext('Virtual guest seems to be running on source host. Import might fail or have inconsistent state!'),
 901                 'efi-state-lost': Ext.String.format(
 902                     gettext('EFI state cannot be imported, you may need to reconfigure the boot order (see {0})'),
 903                     '<a href="https://pve.proxmox.com/wiki/OVMF/UEFI_Boot_Entries">OVMF/UEFI Boot Entries</a>',
 904                 ),
 905             };
 906             let message = warningsCatalogue[w.type];
 907             if (!w.type || !message) {
 908                 return w.message ?? w.type ?? gettext('Unknown warning');
 909             }
 910             return Ext.String.format(message, w.key ?? 'unknown', w.value ?? 'unknown');
 911         };
 912
 913         me.load({
 914             success: function(response) {
 915                 let data = response.result.data;
 916                 me.vmConfig = data['create-args'];
 917
 918                 let disks = [];
 919                 for (const [id, value] of Object.entries(data.disks ?? {})) {
 920                     let volid = Ext.htmlEncode('<none>');
 921                     let size = 'auto';
 922                     if (Ext.isObject(value)) {
 923                         volid = value.volid;
 924                         size = value.size;
 925                     }
 926                     disks.push({
 927                         id,
 928                         enable: true,
 929                         size,
 930                         'import-from': volid,
 931                         format: 'raw',
 932                     });
 933                 }
 934
 935                 let nets = [];
 936                 for (const [id, parsed] of Object.entries(data.net ?? {})) {
 937                     parsed.id = id;
 938                     parsed.enable = true;
 939                     nets.push(parsed);
 940                 }
 941
 942                 let cdroms = [];
 943                 for (const [id, value] of Object.entries(me.vmConfig)) {
 944                     if (!Ext.isString(value) || !value.match(/media=cdrom/)) {
 945                         continue;
 946                     }
 947                     cdroms.push({
 948                         enable: true,
 949                         hidden: false,
 950                         id,
 951                     });
 952                     delete me.vmConfig[id];
 953                 }
 954
 955                 me.lookup('diskGrid').getStore().setData(disks);
 956                 me.lookup('netGrid').getStore().setData(nets);
 957                 me.lookup('cdGrid').getStore().setData(cdroms);
 958
 959                 let additionalCdIdx = me.getController().calculateAdditionalCDIdx();
 960                 if (additionalCdIdx === '') {
 961                     me.getViewModel().set('maxCdDrives', true);
 962                 } else if (cdroms.length === 0) {
 963                     me.additionalCdIdx = additionalCdIdx;
 964                     me.lookup('cdGrid').getStore().add({
 965                         enable: true,
 966                         hidden: !(me.vmConfig.ostype ?? '').startsWith('w'),
 967                         id: additionalCdIdx,
 968                         autogenerated: true,
 969                     });
 970                 }
 971
 972                 me.getViewModel().set('warnings', data.warnings.map(w => renderWarning(w)));
 973
 974                 let osinfo = PVE.Utils.get_kvm_osinfo(me.vmConfig.ostype ?? '');
 975                 let mapSata = (me.vmConfig.ostype ?? '').startsWith('w') && (me.vmConfig.bios ?? '').indexOf('ovmf') !== -1;
 976
 977                 me.setValues({
 978                     osbase: osinfo.base,
 979                     ...me.vmConfig,
 980                 });
 981
 982
 983                 me.lookup('mapSata').setValue(mapSata);
 984             },
 985         });
 986     },
 987 });